Official Account Management

1. Operation description

The following forms are the necessary steps for official account event tracking, please follow the sequence:

1.1 Integrate into official account

Product path: 「Data tracking」-「Data Source Management」-「Official Account Management」

Click 「Integrate into Official Account」 button. On the right 「ntegrate into Data Source」 page to complete creation, the following information is required:

「Basic information」

• Name of official account: fill in the name of the official account to be accessed

• official account ID: Enter the official account ID. The official account ID must be unique. The following figure shows how to obtain the data:

「Analysis settings」

• Belonged organization: By default, the current organization cannot be modified. If you want to add an official account to a different organization, you must switch the organization from the left-side Group drop-down list.

• Belonged application: Select an application in the current organization from the drop-down list.

「Receive WeChat messages」

• Encryption mode: divided into security mode and plaintext mode;

Security mode: EncodingAESKey is used to message body the encryption and decryption key, which is the same as the WeChat public number platform.

Plaintext mode: does not use the message body encryption and decryption function, low security factor.

• To obtain the EncodingAESKey, run the following code: official account backend-basic configurations-copy EncodingAESKey.

• Token acquisition address: official account backend-basic configuration-copy Token

(Note: The backend URL of WeChat official account is the address filled in by the user. WeChat official account sends the data to the filled in address and then synchronizes it to Quick Tracking. Reference Documentation)

「Anonymous user unique identifier」

Required. The union or OpenID is used as the unique identifier for anonymous users.

• OpenID: the unique identifier of the user.

• UnionID: a unique value used to distinguish users. After you set this parameter to UnionID, you must obtain the access_token.

「Obtain access_token」

If other businesses use tokens at the same time, you need to build the central control service to obtain and maintain the access_token. In the analysis platform, you can obtain the access_token from the central control service. (Note: If you select unionID as the unique identifier for anonymous users, users must configure a control center. Quick Tracking obtains the token through the central control center and obtains the corresponding unionID in WeChat official account (because the token will be refreshed after each call to obtain the token, the token used in other locations will also be refreshed and changed. And the number of token acquisition WeChat development platform has restrictions, users can obtain token from the control center, and can control the period of token))

• Central control server address: Enter the self-built central control service address to obtain the token central control service address;

• Access_token parsing: The Access_Token parameter is parsed from the return value obtained from the central control server. The Access_Token parameter is parsed by using the JSONPah expression. Enter the JSONPath expression and click Test to test whether the Access_Token parameter is parsed. If the Access_Token parameter is parsed, the Access_Token parameter can be obtained normally.

Complete the above steps and click Save to complete the creation.

1.2 Official account management

The official account action area is mainly composed of the following parts:

• Organization screening area on the left: switch official accounts accessed under different organizations

• Data display area: displays the list of connected official accounts. The data includes the official account name, official account APPID, creator, application, and actions. Note: In the analysis settings, a public number can only belong to one application.

• Action area: The action area contains 「Edit」 and 「Action」. After clicking 「Edit」, it is the same as the new interface. If you click Delete, the association of the official account is removed from the application.

1.3 Data analysis

For applications after accessing the official account, as well as analysis views and small stations with "applications after accessing the official account", official account events need to be included in the system attributes to participate in the analysis. The system attributes participating in the analysis are as follows:

The analysis models for revealing official account events include: event analysis, funnel analysis, retention analysis, distribution analysis, interval analysis, path analysis, lifecycle analysis, attribution analysis, and audience management.

2 Events and event attributes

WeChat official account events are defined, generated, and sent by WeChat. Developers only subscribe to these data and cannot customize them. Specific event list that can be subscribed are as follows:

3 Event tracking

3.1 server tracking parameters tracking

1. Go to the management console --> Click track information

2. Primary domain name: the address for reporting server tracking data

3. Sub-domain: The default domain is the same as the primary domain. Private deployment customers can provide sub-domain names as alternate domain names.

4. The ServiceSecret and ServiceID are verification parameters. Do not disclose the secret.

5. The code parameter specifies the developer ID(AppID). This parameter is required from the WeChat public ID platform and must be configured in the tracking management-data source management-official account management.

Note: Because the above information involves system security, only administrator rights can see it!

3.2 Request parameters

API address: https://<data tracking endpoint + Port> /server/thirdPartyDataSource

request parameters content-type:application/json

Request JSON parameters:

<xml><ToUserName><![CDATA[gh_0b03a4dd7455]]></ToUserName>
<FromUserName><![CDATA[o884561i2yjDrOhC6IqzEzXtPKUo]]></FromUserName>
<CreateTime>1676613107</CreateTime>
<MsgType><![CDATA[text]]></MsgType>
<Content><! [CDATA [Test]]></Content>
<MsgId>24003327368861869</MsgId>
</xml>

3.3 Authentication sign generation rules

1. First, encapsulate the keys and values of all request fields except the sign field into a map object

2. To serialize this map object into JSON characters, the keys need to be sorted according to the natural order, that is, the ASCII code. Java can use JSONObject.toJSONString(mapObject, SerializerFeature.MapSortField),

3. Get serviceSecret

4. sign = MD5 (JSON characters generated after sorting + serviceSecret)

5. Put the calculated sign into the original map object and serialize it into JSON characters, which is the final complete JSON request message.

3.4 Response description

Response data content-type:application/json

The response JSON contains two fields: code and message

3.5 java demo reference

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.google.gson.Gson;
import okhttp3.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.Charset;
import java.util.HashMap;
import java.util.Map;

/**
* ThirdPartyDataSourceApiDemo access the third-party data source demo
*
* @author chengtao
*/
public class ThirdPartyDataSourceApiDemo {
     private static final Logger logger = LoggerFactory.getLogger(ThirdPartyDataSourceApiDemo.class);

    /**
     * Primary domain name
     */
    private static final String API_URL = "*****";

    /**
     * Corresponds to the ServiceID in the server tracking information.
     */
    private static final String SERVICE_ID = "*****";

    /**
     * Corresponds to the ServiceSecret in the server tracking information.
     */
    private static final String SERVICE_SECRET = "*****";

    /**
     * Client logs
     */
    private static final OkHttpClient client = new OkHttpClient();

    /**
     * Obtain WeChat public number log and forward it to QT for tracking (this interface needs to be configured in WeChat public number management background)
     * 
     * @param request
     * @throws IOException
     */
    @RequestMapping("/token")
    @ResponseBody
    public void token(HttpServletRequest request) throws IOException {
        // Obtain all parameters in the official WeChat public number request and encapsulate them in JSON format.
        Map<String, String[]> paramMap = request.getParameterMap();

        JSONObject json = paramMapToJson(paramMap);

        // Add the service ID to the message.
        json.put("app_id",SERVICE_ID);

        // Add ts to the message.
        json.put("ts", String.valueOf(System.currentTimeMillis()));

        // Enter the public ID.
        String code = "******";
        json.put("code", code);

        // Obtain the XML data of the WeChat public number.
        String weChatOAData = new String(InputStreamUtil.getBytes(request));
        json.put("weChatOAData", weChatOAData);

        //Calculate the signature
        String sign = MD5Util.md5(JSONObject.toJSONString(json, SerializerFeature.MapSortField) + SERVICE_SECRET);

        json.put("sign", sign);

        String desJsonString = JSON.toJSONString(json, SerializerFeature.DisableCircularReferenceDetect);

        Request newRequest = new Request.Builder()
                .URL(API_URL + "/server")
                .post(RequestBody.create(MediaType.parse("application/json"),
                        desJsonString))
                .build();
        try {
            Response response = client.newCall(newRequest).execute();
            if (!response.isSuccessful()) {
                System.out.printf("[DEMO] Failed to send log %s%n", response);
            } else {
                System.out.printf("[DEMO] Sent successfully %s%n",
                        response.body().string());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static JSONObject paramMapToJson(Map<String, String[]> paramMap) {
        Map<String, Object> bodyMap = new HashMap<>();
        for (Map.Entry<String, String[]> entry : paramMap.entrySet()) {
            String key = entry.getKey();
            String[] value = entry.getValue();
            if (value.length == 1) {
                bodyMap.put(key, value[0]);
            } else {
                bodyMap.put(key, value);
            }
        }
        return JSON.parseObject(new Gson().toJson(bodyMap));
    }

    private static String getBodyString(HttpServletRequest request) {
        StringBuilder sb = new StringBuilder();
        InputStream inputStream = null;
        BufferedReader reader = null;
        try {
            inputStream = request.getInputStream();
            reader = new BufferedReader(new InputStreamReader(inputStream, Charset.forName("UTF-8")));
            String line = "";
            while ((line = reader.readLine()) != null) {
                sb.append(line);
            }
        } catch (IOException e) {
            logger.error("read body error", e);
            throw new RuntimeException("read body error");
        } finally {
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    logger.error("close inputStream error", e);
                }
            }
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    logger.error("close reader error", e);
                }
            }
        }
        return sb.toString();
    }
}


public class MD5Util {

    public static String md5(String s) {
        char hexDigits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
        try {
            byte[] btInput = s.getBytes();
            // Obtain the MessageDigest object of the MD5 digest algorithm.
            MessageDigest mdInst = MessageDigest.getInstance("MD5");
            // Update the digest with the specified bytes
            mdInst.update(btInput);
            // Obtain the ciphertext.
            byte[] md = mdInst.digest();
            // Convert the ciphertext into a hexadecimal string.
            int j = md.length;
            char str[] = new char[j * 2];
            int k = 0;
            for (int i = 0; i < j; i++) {
                byte byte0 = md[i];
                str[k++] = hexDigits[byte0 >>> 4 & 0xf];
                str[k++] = hexDigits[byte0 & 0xf];
            }
            return new String(str);
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * Unit testing
     */
    public static void main(String[] args) {
        StringBuilder dtskey = new StringBuilder("abc12390");
        dtskey.append('\0').append("~!@#$%^&*()_+");
        System.out.println(MD5Util.md5(dtskey.toString()));
        System.out.println(MD5Util.md5("20121221"));
        System.out.println(MD5Util.md5("Encryption"));
    }
}