cn.jiguang.common.resp.APIRequestException Java Examples

public ResponseWrapper doRequest(String url, String content, 
        RequestMethod method) throws APIConnectionException, APIRequestException {
    ResponseWrapper response = null;
    for (int retryTimes = 0; ; retryTimes++) {
        try {
            response = _doRequest(url, content, method);
            break;
        } catch (SocketTimeoutException e) {
            if (KEYWORDS_READ_TIMED_OUT.equals(e.getMessage())) {
                // Read timed out.  For push, maybe should not re-send.
                throw new APIConnectionException(READ_TIMED_OUT_MESSAGE, e, true);
            } else {    // connect timed out
                if (retryTimes >= _maxRetryTimes) {
                    throw new APIConnectionException(CONNECT_TIMED_OUT_MESSAGE, e, retryTimes);
                } else {
                    LOG.debug("connect timed out - retry again - " + (retryTimes + 1));
                }
            }
        }
    }
    return response;
}
 

/**
 * Add Users to black list
 *
 * @param username The owner of the black list
 * @param users    The users that will add to black list
 * @return add users to black list
 * @throws APIConnectionException connect exception
 * @throws APIRequestException    request exception
 */
public ResponseWrapper addBlackList(String username, String... users)
        throws APIConnectionException, APIRequestException {
    StringUtils.checkUsername(username);
    Preconditions.checkArgument(null != users && users.length > 0, "black list should not be empty");

    JsonArray array = new JsonArray();
    for (String user : users) {
        array.add(new JsonPrimitive(user));
    }
    return _httpClient.sendPut(_baseUrl + userPath + "/" + username + "/blacklist", array.toString());
}
 

public GroupListResult getGroupListByAppkey(int start, int count)
        throws APIConnectionException, APIRequestException {
    if (start < 0 || count <= 0 || count > 500) {
        throw new IllegalArgumentException("negative index or count must more than 0 and less than 501");
    }
    ResponseWrapper response = _httpClient.sendGet(_baseUrl + groupPath + "?start=" + start + "&count=" + count);
    return GroupListResult.fromResponse(response, GroupListResult.class);
}
 

public GroupInfoResult getGroupInfo(long gid)
        throws APIConnectionException, APIRequestException {
    Preconditions.checkArgument(gid > 0, "gid should more than 0.");

    ResponseWrapper response = _httpClient.sendGet(_baseUrl + groupPath + "/" + gid);

    return GroupInfoResult.fromResponse(response, GroupInfoResult.class);
}
 

/**
 * Download file with mediaId, will return DownloadResult which include url.
 * @param mediaId Necessary
 * @return DownloadResult
 * @throws APIConnectionException connect exception
 * @throws APIRequestException request exception
 */
public DownloadResult downloadFile(String mediaId)
        throws APIConnectionException, APIRequestException {
    Preconditions.checkArgument(null != mediaId, "mediaId is necessary");

    ResponseWrapper response = _httpClient.sendGet(_baseUrl + resourcePath + "?mediaId=" + mediaId);
    return DownloadResult.fromResponse(response, DownloadResult.class);
}
 

/**
 * get chatroom history message
 * @param chatroomid
 * @param cursor must greater than zero and less than 1000
 * @return
 */
public ChatRoomHistoryResult getChatRoomHistory(Long chatroomid, String cursor)
    throws APIConnectionException, APIRequestException {
    Preconditions.checkArgument(cursor != null && cursor.length() > 0, "count is invalid");
    String requestUrl = reportBaseUrl + v2_chatroomPath + "/" + chatroomid + "/" + "messages" + "?cursor=" + cursor;
    ResponseWrapper response = _httpClient.sendGet(requestUrl);
    return ChatRoomHistoryResult.fromResponse(response, ChatRoomHistoryResult.class);
}
 

public CreateGroupResult createGroup(GroupPayload payload)
        throws APIConnectionException, APIRequestException {
    Preconditions.checkArgument(!(null == payload), "group payload should not be null");

    ResponseWrapper response = _httpClient.sendPost(_baseUrl + groupPath, payload.toString());
    return CreateGroupResult.fromResponse(response, CreateGroupResult.class);
}
 

/**
 * Delete friends
 *
 * @param username Friends you want to delete to
 * @param users    username to be delete
 * @return No content
 * @throws APIConnectionException connect exception
 * @throws APIRequestException    request exception
 */
public ResponseWrapper deleteFriends(String username, String... users)
        throws APIConnectionException, APIRequestException {
    StringUtils.checkUsername(username);
    Preconditions.checkArgument(null != users && users.length > 0, "friend list should not be empty");

    JsonArray array = new JsonArray();
    for (String user : users) {
        array.add(new JsonPrimitive(user));
    }
    return _httpClient.sendDelete(_baseUrl + userPath + "/" + username + "/friends", array.toString());
}
 

/**
 * Please use {@link cn.jmessage.api.reportv2.ReportClient#v2GetUserMessagesByCursor}
 * Get user's message list with cursor, the cursor will effective in 120 seconds.
 * And will return same count of messages as first request.
 * @param username Necessary parameter.
 * @param cursor First request will return cursor
 * @return MessageListResult
 * @throws APIConnectionException connect exception
 * @throws APIRequestException request exception
 */
@Deprecated
public MessageListResult getUserMessagesByCursor(String username, String cursor)
        throws APIConnectionException, APIRequestException {
    StringUtils.checkUsername(username);
    if (null != cursor) {
        String requestUrl = reportBaseUrl + v2_userPath + "/" + username + "/messages?cursor=" + cursor;
        ResponseWrapper response = _httpClient.sendGet(requestUrl);
        return MessageListResult.fromResponse(response, MessageListResult.class);
    } else {
        throw new IllegalArgumentException("the cursor parameter should not be null");
    }
}
 

/**
 * Please use {@link cn.jmessage.api.reportv2.ReportClient#v2GetUserMessagesByCursor(String, String)}
 * Get message list with cursor, the cursor will effective in 120 seconds. And will
 * return same count of messages as first request.
 * @param cursor First request will return cursor
 * @return MessageListResult
 * @throws APIConnectionException connect exception
 * @throws APIRequestException request exception
 */
@Deprecated
public MessageListResult getMessageListByCursor(String cursor)
        throws APIConnectionException, APIRequestException {
    if (null != cursor) {
        String requestUrl = reportBaseUrl + v2_messagePath + "?cursor=" + cursor;
        ResponseWrapper response = _httpClient.sendGet(requestUrl);
        return MessageListResult.fromResponse(response, MessageListResult.class);
    } else {
        throw new IllegalArgumentException("the cursor parameter should not be null");
    }
}
 

public String registerUsers(RegisterInfo[] users)
        throws APIConnectionException, APIRequestException {
    RegisterPayload payload = RegisterPayload.newBuilder()
            .addUsers(users)
            .build();

    return _userClient.registerUsers(payload).responseContent;
}
 

/**
 * Update friends' note information. The size is limit to 500.
 *
 * @param username Necessary
 * @param array    FriendNote array
 * @return No content
 * @throws APIConnectionException connect exception
 * @throws APIRequestException    request exception
 */
public ResponseWrapper updateFriendsNote(String username, FriendNote[] array)
        throws APIConnectionException, APIRequestException {
    StringUtils.checkUsername(username);
    FriendNotePayload payload = new FriendNotePayload.Builder()
            .setFriendNotes(array)
            .build();
    Preconditions.checkArgument(null != payload, "FriendNotePayload should not be null");
    return _httpClient.sendPut(_baseUrl + userPath + "/" + username + "/friends", payload.toString());
}
 

/**
 * Get chat room information by room ids
 *
 * @param roomIds Array of room id
 * @return {@link ChatRoomListResult}
 * @throws APIConnectionException connect exception
 * @throws APIRequestException    request exception
 */
public ChatRoomListResult getBatchChatRoomInfo(long... roomIds) throws APIConnectionException, APIRequestException {
    Preconditions.checkArgument(roomIds != null && roomIds.length > 0, "Room ids should not be null");
    JsonArray array = new JsonArray();
    for (long id : roomIds) {
        array.add(new JsonPrimitive(id));
    }
    ResponseWrapper responseWrapper = _httpClient.sendPost(_baseUrl + mChatRoomPath + "/batch", array.toString());
    return ChatRoomListResult.fromResponse(responseWrapper);
}
 

/**
 * create sign
 * 其实两个接口可以合并 但没时间搞
 *
 * @param payload {@link SignPayload }
 * @return SignResult
 * @throws APIConnectionException connect exception
 * @throws APIRequestException    request exception
 */
public SignResult createSign(SignPayload payload) throws APIConnectionException, APIRequestException {
    Preconditions.checkArgument(null != payload, "sign payload should not be null");
    Preconditions.checkArgument(payload.getType() > 0 && payload.getType() <= 7,
            "type should be between 1 and 7");
    Map<String, Object> params = new HashMap<String, Object>();
    params.put(SignPayload.getSIGN(), payload.getSign());
    if (!StringUtils.isEmpty(payload.getRemark())) {
        Preconditions.checkArgument(payload.getRemark().length() <= 100,
                "remark too long");
        params.put(SignPayload.getREMARK(), payload.getRemark());
    }
    params.put(SignPayload.getTYPE(), payload.getType());
    Map<String, byte[]> fileParams = new HashMap<String, byte[]>();
    File[] images = payload.getImages();
    if (images != null && images.length > 0) {
        for (File file : payload.getImages()) {
            fileParams.put(file.getName(), getBytes(file));
        }
    }
    String url = _baseUrl + _signPath;
    try {
        ResponseWrapper wrapper = doPostSign(url, params, fileParams, SignPayload.getIMAGES());
        if (wrapper.responseCode != 200) {
            throw new APIRequestException(wrapper);
        }
        return SignResult.fromResponse(wrapper, SignResult.class);
    } catch (IOException e) {
        e.printStackTrace();
        throw new IllegalArgumentException("fail to creat sign");
    }
}
 

/**
 * update sign
 *
 * @param payload {@link SignPayload }
 * @param signId necessary
 * @return SignResult
 * @throws APIConnectionException connect exception
 * @throws APIRequestException    request exception
 */
public SignResult updateSign(SignPayload payload, int signId) throws APIConnectionException, APIRequestException {
    Preconditions.checkArgument(null != payload, "sign payload should not be null");
    Preconditions.checkArgument(payload.getType() > 0 && payload.getType() <= 7,
            "type should be between 1 and 7");

    Map<String, Object> params = new HashMap<String, Object>();
    params.put(SignPayload.getSIGN(), payload.getSign());
    if (!StringUtils.isEmpty(payload.getRemark())) {
        Preconditions.checkArgument(payload.getRemark().length() <= 100,
                "remark too long");
        params.put(SignPayload.getREMARK(), payload.getRemark());
    }
    params.put(SignPayload.getTYPE(), payload.getType());
    Map<String, byte[]> fileParams = new HashMap<String, byte[]>();
    File[] images = payload.getImages();
    if (images != null && images.length > 0) {
        for (File file : payload.getImages()) {
            fileParams.put(file.getName(), getBytes(file));
        }
    }
    String url = _baseUrl + _signPath + "/" + signId;
    try {
        ResponseWrapper wrapper = doPostSign(url, params, fileParams, SignPayload.getIMAGES());
        if (wrapper.responseCode != 200) {
            throw new APIRequestException(wrapper);
        }
        return SignResult.fromResponse(wrapper, SignResult.class);
    } catch (IOException e) {
        e.printStackTrace();
        throw new IllegalArgumentException("fail to update sign");
    }
}
 

public UserInfoResult getUserInfo(String username)
        throws APIConnectionException, APIRequestException {

    StringUtils.checkUsername(username);
    ResponseWrapper response = _httpClient.sendGet(_baseUrl + userPath + "/" + username);
    return UserInfoResult.fromResponse(response, UserInfoResult.class);
}
 

/**
 * Get user's message list with cursor, the cursor will effective in 120 seconds.
 * And will return same count of messages as first request.
 * @param username Necessary parameter.
 * @param cursor First request will return cursor
 * @return MessageListResult
 * @throws APIConnectionException connect exception
 * @throws APIRequestException request exception
 */
public MessageListResult v2GetUserMessagesByCursor(String username, String cursor)
        throws APIConnectionException, APIRequestException {
    StringUtils.checkUsername(username);
    if (null != cursor) {
        String requestUrl = mBaseReportPath + mV2UserPath + "/" + username + "/messages?cursor=" + cursor;
        ResponseWrapper response = _httpClient.sendGet(requestUrl);
        return MessageListResult.fromResponse(response, MessageListResult.class);
    } else {
        throw new IllegalArgumentException("the cursor parameter should not be null");
    }
}
 

public String registerAdmins(String username, String password)
        throws APIConnectionException, APIRequestException {
    RegisterInfo payload = RegisterInfo.newBuilder()
            .setUsername(username)
            .setPassword(password)
            .build();

    return _userClient.registerAdmins(payload).responseContent;
}
 

/**
 * Get user statistic, now time unit only supports DAY
 * @param startTime start time, format: yyyy-MM-dd
 * @param duration 0-60
 * @return {@link UserStatListResult}
 * @throws APIConnectionException connect exception
 * @throws APIRequestException request exception
 */
public UserStatListResult getUserStatistic(String startTime, int duration)
        throws APIConnectionException, APIRequestException {
    Preconditions.checkArgument(verifyDateFormat("DAY", startTime), "Illegal date format");
    Preconditions.checkArgument(0 <= duration && duration <= 60, " 0 <= duration <= 60");
    String url = mBaseReportPath + mV2StatisticPath + "/users?time_unit=DAY&start=" + startTime + "&duration=" + duration;
    ResponseWrapper responseWrapper = _httpClient.sendGet(url);
    return UserStatListResult.fromResponse(responseWrapper);
}
 

/**
 * Get message statistic. Detail instructions please refer to https://docs.jiguang.cn/jmessage/server/rest_api_im_report_v2/#_6
 * @param timeUnit MUST be one of HOUR, DAY, MONTH
 * @param start start time, when timeUnit is HOUR, format: yyyy-MM-dd HH,
 * @param duration depends on timeUnit, the duration has limit
 * @return {@link MessageStatListResult}
 * @throws APIConnectionException connect exception
 * @throws APIRequestException request exception
 */
public MessageStatListResult getMessageStatistic(String timeUnit, String start, int duration)
        throws APIConnectionException, APIRequestException {
    Preconditions.checkArgument(verifyDateFormat(timeUnit, start), "Time format error, please check your argument");
    if (timeUnit.equals("HOUR")) {
        Preconditions.checkArgument(0 <= duration && duration <= 24, "time unit is HOUR, duration must between 0 and 24 ");
    } else if (timeUnit.equals("DAY")) {
        Preconditions.checkArgument(0 <= duration && duration <= 60, "time unit is DAY, duration must between 0 and 60");
    } else if (timeUnit.equals("MONTH")) {
        Preconditions.checkArgument(0 <= duration && duration <= 2, "time unit is MONTH, duration must between 0 and 2");
    } else throw new IllegalArgumentException("Time unit error");
    String url = mBaseReportPath + mV2StatisticPath + "/messages?time_unit=" + timeUnit + "&start=" + start + "&duration=" + duration;
    ResponseWrapper responseWrapper = _httpClient.sendGet(url);
    return MessageStatListResult.fromResponse(responseWrapper, MessageStatListResult.class);
}
 

/**
 * Send SMS verification code to server, to verify if the code valid
 *
 * @param msgId The message id of the verification code
 * @param code  Verification code
 * @return return ValidSMSResult includes is_valid
 * @throws APIConnectionException connection exception
 * @throws APIRequestException    request exception
 */
public ValidSMSResult sendValidSMSCode(String msgId, String code)
        throws APIConnectionException, APIRequestException {
    Preconditions.checkArgument(null != msgId, "Message id should not be null");
    Pattern codePattern = Pattern.compile("^[0-9]{6}");
    Preconditions.checkArgument(codePattern.matcher(code).matches(), "The verification code shoude be consist of six number");
    JsonObject json = new JsonObject();
    json.addProperty(SMS_CODE, code);

    ResponseWrapper response = _httpClient.sendPost(_baseUrl + _smsCodePath + "/" + msgId + _validPath, json.toString());
    return ValidSMSResult.fromResponse(response, ValidSMSResult.class);
}
 

public ResponseWrapper removeBlackList(String username, String... users)
        throws APIConnectionException, APIRequestException {
    StringUtils.checkUsername(username);
    Preconditions.checkArgument(null != users && users.length > 0, "black list should not be empty");
    JsonArray array = new JsonArray();
    for (String user : users) {
        array.add(new JsonPrimitive(user));
    }

    return _httpClient.sendDelete(_baseUrl + userPath + "/" + username + "/blacklist", array.toString());
}
 

public SendMessageResult sendMessage(MessagePayload payload)
        throws APIConnectionException, APIRequestException {
    Preconditions.checkArgument(!(null == payload), "Message payload should not be null");

    ResponseWrapper response = _httpClient.sendPost(_baseUrl + messagePath, payload.toString());
    return SendMessageResult.fromResponse(response, SendMessageResult.class);
}
 

@Override
public ResponseWrapper sendGet(String url) throws APIConnectionException, APIRequestException {
    return sendGet(url, null);
}
 

public ResponseWrapper sendDelete(String url, String content)
throws APIConnectionException, APIRequestException;
 

public ResponseWrapper sendDelete(String url, String content) throws APIConnectionException, APIRequestException {
    return sendHttpRequest(HttpMethod.DELETE, url, content);
}
 

public ResponseWrapper sendPost(String url, String content) 
           throws APIConnectionException, APIRequestException {
	return doRequest(url, content, RequestMethod.POST);
}
 

public ResponseWrapper sendGet(String url, String content)
		throws APIConnectionException, APIRequestException {
	return doRequest(url, content, RequestMethod.GET);
}
 

public ResponseWrapper sendDelete(String url, String content)
		throws APIConnectionException, APIRequestException {
	return doRequest(url, content, RequestMethod.DELETE);
}
 

public ResponseWrapper setGroupMemberSilence(long gid, boolean status, String[] usernames)
    throws APIConnectionException, APIRequestException {
    Preconditions.checkArgument(gid > 0, "gid should more than 0.");
    Preconditions.checkArgument(usernames != null && usernames.length > 0, "username array is invalid");
    return _httpClient.sendPut(_baseUrl + groupPath + "/messages/" + gid + "/silence?status=" + (status ? "true" : "false"), new Gson().toJson(usernames));
}