Java Code Examples for net.sf.json.JSONArray#toCollection()

/**
 * アイテム情報を更新します。<br/>
 * itemidパラメータを必ず指定する必要があります。
 *
 * @param param {@link ItemUpdateParam}
 * @return 更新したアイテム情報のitemidのリスト
 */
@SuppressWarnings("unchecked")
public List<String> update(ItemUpdateParam param) {
    if (param.getItemid() == null) {
        throw new IllegalArgumentException("itemid is required.");
    }

    JSONObject params = JSONObject.fromObject(param, defaultConfig);
    JSONObject result = (JSONObject) accessor.execute("item.update", params);
    JSONArray itemids = result.getJSONArray("itemids");
    JsonConfig config = defaultConfig.copy();
    config.setCollectionType(List.class);
    config.setRootClass(String.class);

    return (List<String>) JSONArray.toCollection(itemids, config);
}
 

/**
 * アイテム情報を取得します。<br/>
 * アイテム情報が存在しない場合、空のリストを返します。
 *
 * @param param {@link ItemGetParam}
 * @return 取得したアイテム情報のリスト
 */
@SuppressWarnings("unchecked")
public List<Item> get(ItemGetParam param) {
    JSONObject params = JSONObject.fromObject(param, defaultConfig);
    JSONArray result = (JSONArray) accessor.execute("item.get", params);

    JsonConfig config = defaultConfig.copy();
    config.setCollectionType(List.class);
    config.setRootClass(Item.class);
    config.setJavaPropertyFilter(new PropertyFilter() {
        @Override
        public boolean apply(Object source, String name, Object value) {
            if ("hosts".equals(name)) {
                return true;
            }
            return false;
        }
    });

    return (List<Item>) JSONArray.toCollection(result, config);
}
 

/**
 * ユーザ情報を作成します。<br/>
 * aliasパラメータを必ず指定する必要があります。<br/>
 * 既に存在するユーザのaliasを指定した場合、例外をスローします。
 *
 * @param param {@link UserCreateParam}
 * @return 作成されたユーザ情報のuseridのリスト
 */
@SuppressWarnings("unchecked")
public List<String> create(UserCreateParam param) {
    if (param.getAlias() == null || param.getAlias().length() == 0) {
        throw new IllegalArgumentException("alias is required.");
    }
    if (accessor.checkVersion("2.0") >= 0) {
        if (param.getPasswd() == null || param.getPasswd().length() == 0) {
            throw new IllegalArgumentException("passwd is required.");
        }

        if (param.getUsrgrps() == null || param.getUsrgrps().isEmpty()) {
            throw new IllegalArgumentException("usrgrps is required.");
        }
    }

    JSONObject params = JSONObject.fromObject(param, defaultConfig);
    JSONObject result = (JSONObject) accessor.execute("user.create", params);

    JSONArray userids = result.getJSONArray("userids");
    JsonConfig config = defaultConfig.copy();
    config.setCollectionType(List.class);
    config.setRootClass(String.class);
    return (List<String>) JSONArray.toCollection(userids, config);
}
 

/**
 * ユーザ情報を取得します。<br/>
 * ユーザ情報が存在しない場合、空のリストを返します。
 *
 * @param param {@link UserGetParam}
 * @return 取得したユーザ情報のリスト
 */
@SuppressWarnings("unchecked")
public List<User> get(UserGetParam param) {
    JSONObject params = JSONObject.fromObject(param, defaultConfig);
    if (accessor.checkVersion("2.0") < 0) {
        if (params.containsKey("selectUsrgrps")) {
            params.put("select_usrgrps", params.remove("selectUsrgrps"));
        }
    }

    JSONArray result = (JSONArray) accessor.execute("user.get", params);

    JsonConfig config = defaultConfig.copy();
    config.setCollectionType(List.class);
    config.setRootClass(User.class);
    config.getClassMap().put("usrgrps", Usergroup.class);
    return (List<User>) JSONArray.toCollection(result, config);
}
 

/**
 * ユーザグループ情報とユーザ情報、権限情報を紐付けます。
 * userids,usrgrpidsパラメータを必ず指定する必要があります。<br/>
 * @param param {@link UsergroupMassAddParam}
 * @return 更新されたユーザグループ情報のusrgrpidのリスト
 */
public List<String> massAdd(UsergroupMassAddParam param) {
    if (param.getUserids() == null || param.getUserids().isEmpty()) {
        throw new IllegalArgumentException("userids is required.");
    }
    if (param.getUsrgrpids() == null || param.getUsrgrpids().isEmpty()) {
        throw new IllegalArgumentException("usrgrpids is required.");
    }
    JSONObject params = JSONObject.fromObject(param, defaultConfig);
    JSONObject result = (JSONObject) accessor.execute("usergroup.massAdd", params);

    JSONArray usrgrpids = result.getJSONArray("usrgrpids");
    JsonConfig config = defaultConfig.copy();
    config.setCollectionType(List.class);
    config.setRootClass(String.class);

    // Zabbix 2.2.9でusrgrpidsが数値のArrayとして返ってくることへの対応
    List<?> ids = (List<?>) JSONArray.toCollection(usrgrpids, config);
    List<String> resultIds = new ArrayList<String>();
    for (Object id : ids) {
        resultIds.add(id.toString());
    }
    return resultIds;
}
 

/**
 * ユーザグループ情報を更新します。
 * usrgrpidパラメータを必ず指定する必要があります。<br/>
 * @param param {@link UsergroupUpdateParam}
 * @return 更新されたユーザグループ情報のusrgrpidのリスト
 */
@SuppressWarnings("unchecked")
public List<String> update(UsergroupUpdateParam param) {
    if (param.getUsrgrpid() == null || param.getUsrgrpid().length() == 0) {
        throw new IllegalArgumentException("usrgrpid is required.");
    }

    JSONObject params = JSONObject.fromObject(param, defaultConfig);
    if (accessor.checkVersion("2.0") >= 0) {
        // api_accessは2.0以降で廃止されたパラメータ
        if (params.containsKey("api_access")) {
            params.remove("api_access");
        }
    }

    JSONObject result = (JSONObject) accessor.execute("usergroup.update", params);

    JSONArray usrgrpids = result.getJSONArray("usrgrpids");
    JsonConfig config = defaultConfig.copy();
    config.setCollectionType(List.class);
    config.setRootClass(String.class);
    return (List<String>) JSONArray.toCollection(usrgrpids, config);
}
 

/**
 * トリガー情報を取得します。<br/>
 * トリガー情報が存在しない場合、空のリストを返します。
 *
 * @param param {@link TriggerGetParam}
 * @return 取得したトリガー情報のリスト
 */
@SuppressWarnings("unchecked")
public List<Trigger> get(TriggerGetParam param) {
    JSONObject params = JSONObject.fromObject(param, defaultConfig);
    JSONArray result = (JSONArray) accessor.execute("trigger.get", params);

    JsonConfig config = defaultConfig.copy();
    config.setCollectionType(List.class);
    config.setRootClass(Trigger.class);
    config.setJavaPropertyFilter(new PropertyFilter() {
        @Override
        public boolean apply(Object source, String name, Object value) {
            if ("hosts".equals(name)) {
                return true;
            }
            return false;
        }
    });

    return (List<Trigger>) JSONArray.toCollection(result, config);
}
 

/**
 * ユーザグループ情報を削除します。<br/>
 * usrgrpidsパラメータを必ず指定する必要があります。<br/>
 * 存在しないusrgrpidを指定した場合、空のリストを返します。
 *
 * @param usrgrpids usrgrpids
 * @return 削除したユーザグループ情報のusrgrpidのリスト
 */
@SuppressWarnings("unchecked")
public List<String> delete(List<String> usrgrpids) {
    if (usrgrpids == null || usrgrpids.isEmpty()) {
        throw new IllegalArgumentException("usrgrpid is required.");
    }
    JSONArray params = JSONArray.fromObject(usrgrpids, defaultConfig);
    JSONObject result = (JSONObject) accessor.execute("usergroup.delete", params);

    JSONArray resultUsrgrpids = result.getJSONArray("usrgrpids");
    JsonConfig config = defaultConfig.copy();
    config.setCollectionType(List.class);
    config.setRootClass(String.class);
    return (List<String>) JSONArray.toCollection(resultUsrgrpids, config);
}
 

/**
 * アイテム情報を削除します。<br/>
 * itemidsパラメータを必ず指定する必要があります。<br/>
 * 存在しないitemidを指定した場合、例外をスローします。
 *
 * @param itemids itemids
 * @return 削除したアイテム情報のitemidのリスト
 */
public List<String> delete(List<String> itemids) {
    if (itemids == null || itemids.isEmpty()) {
        throw new IllegalArgumentException("itemid is required.");
    }

    JSONArray params = JSONArray.fromObject(itemids, defaultConfig);
    JSONObject result = (JSONObject) accessor.execute("item.delete", params);

    JSONArray itemIds = result.getJSONArray("itemids");
    JsonConfig config = defaultConfig.copy();
    config.setCollectionType(List.class);
    config.setRootClass(String.class);

    List<?> list = (List<?>) JSONArray.toCollection(itemIds, config);

    List<String> itemIdsList = new ArrayList<String>();
    for (Object object : list) {
        if (object instanceof String) {
            itemIdsList.add(String.class.cast(object));
        } else {
            itemIdsList.add(object.toString());
        }
    }

    return itemIdsList;
}
 

/**
 * ユーザ情報を削除します。<br/>
 * useridパラメータを必ず指定する必要があります。<br/>
 * 存在しないuseridを指定した場合、空のリストを返します。
 *
 * @param userid userid
 * @return 削除したユーザ情報のuseridのリスト
 */
@SuppressWarnings("unchecked")
public List<String> delete(List<String> userids) {
    if (userids == null || userids.isEmpty()) {
        throw new IllegalArgumentException("userid is required.");
    }

    JSONArray params;
    if (accessor.checkVersion("2.0") < 0) {
        List<Map<String, String>> list = new ArrayList<Map<String, String>>();
        for (String userid : userids) {
            Map<String, String> map = new HashMap<String, String>();
            map.put("userid", userid);
            list.add(map);
        }
        params = JSONArray.fromObject(list, defaultConfig);
    } else {
        params = JSONArray.fromObject(userids, defaultConfig);
    }

    JSONObject result = (JSONObject) accessor.execute("user.delete", params);

    JSONArray resultUserids = result.getJSONArray("userids");
    JsonConfig config = defaultConfig.copy();
    config.setCollectionType(List.class);
    config.setRootClass(String.class);
    return (List<String>) JSONArray.toCollection(resultUserids, config);
}
 

/**
 * ユーザ情報を更新します。<br/>
 * useridパラメータを必ず指定する必要があります。<br/>
 * 存在しないuseridを指定した場合、例外をスローします。<br/>
 * 既に存在するユーザのaliasを指定した場合、例外をスローします。
 *
 * @param param {@link UserUpdateParam}
 * @return 更新したユーザ情報のuseridのリスト
 */
@SuppressWarnings("unchecked")
public List<String> update(UserUpdateParam param) {
    if (param.getUserid() == null) {
        throw new IllegalArgumentException("userid is required.");
    }
    JSONObject params = JSONObject.fromObject(param, defaultConfig);
    JSONObject result = (JSONObject) accessor.execute("user.update", params);

    JSONArray userids = result.getJSONArray("userids");
    JsonConfig config = defaultConfig.copy();
    config.setCollectionType(List.class);
    config.setRootClass(String.class);
    return (List<String>) JSONArray.toCollection(userids, config);
}
 

/**
 * アプリケーション情報を取得します。<br/>
 * アプリケーション情報が存在しない場合、空のリストを返します。
 *
 * @param param {@link ApplicationGetParam}
 * @return 取得したアプリケーション情報のリスト
 */
@SuppressWarnings("unchecked")
public List<Application> get(ApplicationGetParam param) {
    JSONObject params = JSONObject.fromObject(param, defaultConfig);

    JSONArray result = (JSONArray) accessor.execute("application.get", params);

    JsonConfig config = defaultConfig.copy();
    config.setCollectionType(List.class);
    config.setRootClass(Application.class);
    config.getClassMap().put("hosts", Host.class);

    return (List<Application>) JSONArray.toCollection(result, config);
}
 

/**
 * プロキシ情報を取得します。<br/>
 * プロキシ情報が存在しない場合、空のリストを返します。
 *
 * @param param {@link ProxyGetParam}
 * @return 取得したプロキシ情報のリスト
 */
@SuppressWarnings("unchecked")
public List<Proxy> get(ProxyGetParam param) {
    JSONObject params = JSONObject.fromObject(param, defaultConfig);
    JSONArray result = (JSONArray) accessor.execute("proxy.get", params);

    JsonConfig config = defaultConfig.copy();
    config.setCollectionType(List.class);
    config.setRootClass(Proxy.class);
    return (List<Proxy>) JSONArray.toCollection(result, config);
}
 

@SuppressWarnings("deprecation")
@Test
public void jsonToArrayTest() throws Exception {
    Method fromObject = JSONArray.class.getMethod("fromObject", Object.class);
    Method toArray = JSONArray.class.getMethod("toArray", JSONArray.class);
    Method toList = JSONArray.class.getMethod("toList", JSONArray.class);

    // JSONArray.toCollection() is added in json-lib 2.2. so check toCollection in JSONArray
    Method toCollection = null;
    try {
        toCollection = JSONArray.class.getMethod("toCollection", JSONArray.class);
    } catch (NoSuchMethodException ignored) {
    }

    String json = "[{'string':'JSON'}]";

    JSONArray jsonArray = JSONArray.fromObject(json);

    // JSONArray.toArray() of json-lib 2.0 and below have different return type. so we invoke it by reflection to avoid NoSuchMethodError
    toArray.invoke(null, jsonArray);

    JSONArray.toList(jsonArray);

    if (toCollection != null) {
        JSONArray.toCollection(jsonArray);
    }

    PluginTestVerifier verifier = PluginTestVerifierHolder.getInstance();
    verifier.printCache();

    verifier.verifyTrace(event(SERVICE_TYPE, fromObject, annotation(ANNOTATION_KEY, json.length())));
    verifier.verifyTrace(event(SERVICE_TYPE, toArray));
    verifier.verifyTrace(event(SERVICE_TYPE, toList));
    
    if (toCollection != null) {
        verifier.verifyTrace(event(SERVICE_TYPE, toCollection));
    }

    verifier.verifyTraceCount(0);
}
 

/**
 * ユーザーグループ情報を取得します。<br/>
 * ユーザーグループ情報が存在しない場合、空のリストを返します。
 *
 * @param param {@link UsergroupGetParam}
 * @return 取得したユーザーグループ情報のリスト
 */
@SuppressWarnings("unchecked")
public List<Usergroup> get(UsergroupGetParam param) {
    JSONObject params = JSONObject.fromObject(param, defaultConfig);
    JSONArray result = (JSONArray) accessor.execute("usergroup.get", params);

    JsonConfig config = defaultConfig.copy();
    config.setCollectionType(List.class);
    config.setRootClass(Usergroup.class);
    return (List<Usergroup>) JSONArray.toCollection(result, config);
}
 

/**
 * ホスト情報を削除します。<br/>
 * hostidパラメータを必ず指定する必要があります。<br/>
 * 存在しないhostidを指定した場合、例外をスローします。<br/>
 *
 * @param hostids 削除するホストIDのリスト
 * @return 削除したホスト情報のhostidのリスト
 */
@SuppressWarnings("unchecked")
public List<String> delete(List<String> hostids) {
    if (hostids == null || hostids.isEmpty()) {
        throw new IllegalArgumentException("hostid is required.");
    }

    List<?> param;
    if (accessor.checkVersion("3.0.0") < 0) {
        List<Map<String, String>> list = new ArrayList<Map<String, String>>();
        for (String hostid : hostids) {
            Map<String, String> map = new HashMap<String, String>();
            map.put("hostid", hostid);
            list.add(map);
        }
        param = list;
    } else {
        param = hostids;
    }

    JSONArray params = JSONArray.fromObject(param, defaultConfig);
    JSONObject result = (JSONObject) accessor.execute("host.delete", params);

    JSONArray resultHostids = result.getJSONArray("hostids");
    JsonConfig config = defaultConfig.copy();
    config.setCollectionType(List.class);
    config.setRootClass(String.class);
    return (List<String>) JSONArray.toCollection(resultHostids, config);
}
 

/**
 * ホストグループ情報を削除します。<br/>
 * groupidパラメータを必ず指定する必要があります。<br/>
 * 存在しないgroupidを指定した場合、例外をスローします。<br/>
 *
 * @param groupids 削除するホストグループのIDのリスト
 * @return 削除したホストグループ情報のhostgroupidのリスト
 */
@SuppressWarnings("unchecked")
public List<String> delete(List<String> groupids) {
    if (groupids == null || groupids.isEmpty()) {
        throw new IllegalArgumentException("groupid is required.");
    }

    JSONArray params;
    if (accessor.checkVersion("2.0") < 0) {
        List<Map<String, String>> list = new ArrayList<Map<String, String>>();
        for (String groupid : groupids) {
            Map<String, String> map = new HashMap<String, String>();
            map.put("groupid", groupid);
            list.add(map);
        }
        params = JSONArray.fromObject(list, defaultConfig);
    } else {
        params = JSONArray.fromObject(groupids, defaultConfig);
    }

    JSONObject result = (JSONObject) accessor.execute("hostgroup.delete", params);

    JSONArray hostgroupids = result.getJSONArray("groupids");
    JsonConfig config = defaultConfig.copy();
    config.setCollectionType(List.class);
    config.setRootClass(String.class);
    return (List<String>) JSONArray.toCollection(hostgroupids, config);
}
 

/**
 * ホストグループ情報を更新します。<br/>
 * groupidパラメータを必ず指定する必要があります。<br/>
 * 存在しないgroupidを指定した場合、例外をスローします。<br/>
 *
 * @param param {@link HostgroupUpdateParam}
 * @return 更新したホストグループ情報のhostgroupidのリスト
 */
@SuppressWarnings("unchecked")
public List<String> update(HostgroupUpdateParam param) {
    if (param.getGroupid() == null) {
        throw new IllegalArgumentException("groupid is required.");
    }
    JSONObject params = JSONObject.fromObject(param, defaultConfig);
    JSONObject result = (JSONObject) accessor.execute("hostgroup.update", params);

    JSONArray hostgroupids = result.getJSONArray("groupids");
    JsonConfig config = defaultConfig.copy();
    config.setCollectionType(List.class);
    config.setRootClass(String.class);
    return (List<String>) JSONArray.toCollection(hostgroupids, config);
}
 

/**
 * ホストグループ情報を作成します。<br/>
 * nameパラメータを必ず指定する必要があります。<br/>
 * 既に存在するホストのnameを指定した場合、例外をスローします。
 *
 * @param param {@link HostgroupCreateParam}
 * @return 作成されたホストグループ情報のhostgroupidのリスト
 */
@SuppressWarnings("unchecked")
public List<String> create(HostgroupCreateParam param) {
    if (param.getName() == null || param.getName().length() == 0) {
        throw new IllegalArgumentException("name is required.");
    }
    JSONObject params = JSONObject.fromObject(param, defaultConfig);
    JSONObject result = (JSONObject) accessor.execute("hostgroup.create", params);

    JSONArray hostgroupids = result.getJSONArray("groupids");
    JsonConfig config = defaultConfig.copy();
    config.setCollectionType(List.class);
    config.setRootClass(String.class);
    return (List<String>) JSONArray.toCollection(hostgroupids, config);
}
 

/**
 * ホストグループ情報を取得します。<br/>
 * ホストグループ情報が存在しない場合、空のリストを返します。
 *
 * @param param {@link HostgroupGetParam}
 * @return 取得したホストグループ情報のリスト
 */
@SuppressWarnings("unchecked")
public List<Hostgroup> get(HostgroupGetParam param) {
    JSONObject params = JSONObject.fromObject(param, defaultConfig);
    JSONArray result = (JSONArray) accessor.execute("hostgroup.get", params);

    JsonConfig config = defaultConfig.copy();
    config.setCollectionType(List.class);
    config.setRootClass(Hostgroup.class);
    return (List<Hostgroup>) JSONArray.toCollection(result, config);
}