Java tutorial
/******************************************************************************* * Copyright 2012 The Infinit.e Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. ******************************************************************************/ package com.ikanow.infinit.e.data_model.driver; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; import java.io.UnsupportedEncodingException; import java.net.HttpURLConnection; import java.net.MalformedURLException; import java.net.URL; import java.net.URLConnection; import java.net.URLEncoder; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Collection; import java.util.Date; import java.util.HashMap; import java.util.HashSet; import java.util.LinkedList; import java.util.List; import java.util.Map; import java.util.Set; import org.apache.commons.codec.binary.Base64; import org.apache.commons.io.IOUtils; import org.bson.types.ObjectId; import com.google.common.collect.HashMultimap; import com.google.gson.Gson; import com.google.gson.JsonElement; import com.google.gson.JsonPrimitive; import com.ikanow.infinit.e.data_model.InfiniteEnums.HarvestEnum; import com.ikanow.infinit.e.data_model.api.ApiManager; import com.ikanow.infinit.e.data_model.api.ResponsePojo; import com.ikanow.infinit.e.data_model.api.ResponsePojo.ResponseObject; import com.ikanow.infinit.e.data_model.api.authentication.WordPressAuthPojo; import com.ikanow.infinit.e.data_model.api.authentication.WordPressSetupPojo; import com.ikanow.infinit.e.data_model.api.authentication.WordPressUserPojo; import com.ikanow.infinit.e.data_model.api.config.SourcePojoApiMap; import com.ikanow.infinit.e.data_model.api.custom.mapreduce.CustomMapReduceResultPojo; import com.ikanow.infinit.e.data_model.api.custom.mapreduce.CustomMapReduceResultPojoApiMap; import com.ikanow.infinit.e.data_model.api.knowledge.AdvancedQueryPojo; import com.ikanow.infinit.e.data_model.api.knowledge.DimensionListPojo; import com.ikanow.infinit.e.data_model.api.knowledge.DocumentPojoApiMap; import com.ikanow.infinit.e.data_model.api.knowledge.SearchSuggestPojo; import com.ikanow.infinit.e.data_model.api.social.community.CommunityPojoApiMap; import com.ikanow.infinit.e.data_model.api.social.person.PersonPojoApiMap; import com.ikanow.infinit.e.data_model.api.social.sharing.SharePojoApiMap; import com.ikanow.infinit.e.data_model.store.config.source.SourcePojo; import com.ikanow.infinit.e.data_model.store.custom.mapreduce.CustomMapReduceJobPojo; import com.ikanow.infinit.e.data_model.store.document.DocumentPojo; import com.ikanow.infinit.e.data_model.store.feature.entity.EntityFeaturePojo; import com.ikanow.infinit.e.data_model.store.social.community.CommunityPojo; import com.ikanow.infinit.e.data_model.store.social.person.PersonPojo; import com.ikanow.infinit.e.data_model.store.social.sharing.SharePojo; import com.ikanow.infinit.e.data_model.store.social.sharing.SharePojo.ShareCommunityPojo; import com.ikanow.infinit.e.data_model.utils.TrustManagerManipulator; import com.mongodb.BasicDBObject; import com.mongodb.DBObject; import com.mongodb.util.JSON; public class InfiniteDriver { private static String DEFAULT_API_ROOT = null; private static String DEFAULT_USER = null; private static String DEFAULT_PASSWORD = null; private String apiRoot; private String user; private String password; private String apiKey = null; private String cookie = null; public InfiniteDriver() { apiRoot = DEFAULT_API_ROOT; user = DEFAULT_USER; password = DEFAULT_PASSWORD; } public InfiniteDriver(String apiRootUrl) { if (apiRootUrl == null) apiRoot = DEFAULT_API_ROOT; else apiRoot = apiRootUrl; user = DEFAULT_USER; password = DEFAULT_PASSWORD; } public InfiniteDriver(String apiRootUrl, String apiKey) { if (apiRootUrl == null) apiRoot = DEFAULT_API_ROOT; else apiRoot = apiRootUrl; this.apiKey = "infinitecookie=api:" + apiKey + ";"; // (use it like a cookie to avoid localhost dev issues) // (unused) user = DEFAULT_USER; password = DEFAULT_PASSWORD; } public InfiniteDriver(String apiRootUrl, String username, String unencryptedPassword) { if (apiRootUrl == null) apiRoot = DEFAULT_API_ROOT; else apiRoot = apiRootUrl; if (username == null || unencryptedPassword == null) { user = DEFAULT_USER; password = DEFAULT_PASSWORD; } else { user = username; password = unencryptedPassword; } } static public void setDefaultUser(String username) { DEFAULT_USER = username; } static public void setDefaultPassword(String unencryptedPassword) { DEFAULT_PASSWORD = unencryptedPassword; } static public void setDefaultApiRoot(String rootUrl) { DEFAULT_API_ROOT = rootUrl; } ////////////////////////////////////////////////////////////////////////////////////////////// // AUTHENTICATION // If you already have a valid cookie, then use that: public void useExistingCookie(String existingCookie) { cookie = "infinitecookie=" + existingCookie + "; Path=/; HttpOnly"; } /** * Returns the currently set cookie, can be used to * get the cookie after you login. * * @return */ public String getCookie() { return cookie; } /** * Logs the user in specified by setUser() using the password * specified by setPassword(). * @return true if the user was logged in successfully. */ public Boolean login() { return login(new ResponseObject()); } public Boolean adminLogin() { return adminLogin(new ResponseObject()); } /** * Logs the user in specified by setUser() using the password * specified by setPassword(). * @param responseObject this object will be said from the response of the API call * @return true if the user was logged in successfully. */ public Boolean login(ResponseObject responseObject) { return login(user, password, responseObject); } public Boolean adminLogin(ResponseObject responseObject) { return adminLogin(user, password, responseObject); } /** * Logs the user in with the specified username and password. * This overrides the setUser and setPassword commands * @param username The username to log in * @param password the unencrypted password for the username * @param responseObject this object will be said from the response of the API call * @return true if the user was logged in successfully. */ public Boolean login(String username, String password, ResponseObject responseObject) { try { return doLogin(username, encryptWithoutEncode(password), responseObject); } catch (Exception ex) { ex.printStackTrace(); } return null; } public Boolean login_encrypted(String username, String encrypted_password, ResponseObject responseObject) { return doLogin(username, encrypted_password, responseObject); } private Boolean doLogin(String username, String password, ResponseObject responseObject) { if (null != apiKey) { // Have an API key, don't need to login.... return true; } cookie = null; try { String address = apiRoot + "auth/login/" + username + "/" + URLEncoder.encode(password, "UTF-8"); String loginResult; loginResult = sendRequest(address, null); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(loginResult, ResponsePojo.class); ResponseObject internal_ro = internal_responsePojo.getResponse(); responseObject = shallowCopy(responseObject, internal_ro); return responseObject.isSuccess(); } catch (Exception e) { e.printStackTrace(); } return null; } public Boolean adminLogin(String username, String password, ResponseObject responseObject) { // Allow this even if have an API key because it's currently the only way of knowing if you're an admin cookie = null; try { String address = apiRoot + "auth/login/admin/" + username + "/" + encryptEncodePassword(password); String loginResult; loginResult = sendRequest(address, null); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(loginResult, ResponsePojo.class); ResponseObject internal_ro = internal_responsePojo.getResponse(); responseObject = shallowCopy(responseObject, internal_ro); return responseObject.isSuccess(); } catch (Exception e) { e.printStackTrace(); } return null; } /** * Logs the current logged in user out. * @return true if logout was successful. */ public Boolean logout() { if (null == cookie) { // not logged in, eg have an API key return true; } try { String address = apiRoot + "auth/logout/"; String logoutResult; logoutResult = sendRequest(address, null); ResponsePojo response = ResponsePojo.fromApi(logoutResult, ResponsePojo.class); //cookie set to null so that new cookie will be grabbed on next login cookie = null; return response.getResponse().isSuccess(); } catch (Exception e) { cookie = null; return false; } } /** * Sends a keepalive message * @return true if user is currently logged in */ public Boolean sendKeepalive() { return sendKeepalive(false); } public Boolean sendKeepalive(boolean bAdminOnly) { try { String address = apiRoot + "auth/keepalive"; if (bAdminOnly) { address += "/admin"; } String logoutResult; logoutResult = sendRequest(address, null); ResponsePojo response = ResponsePojo.fromApi(logoutResult, ResponsePojo.class); return response.getResponse().isSuccess(); } catch (Exception e) { return false; } } public Boolean deactivateUser(String username) { try { String deactivateAddress = apiRoot + "auth/deactivate?username=" + URLEncoder.encode(username, "UTF-8"); String deactivateResult = sendRequest(deactivateAddress, null); ResponsePojo response = ResponsePojo.fromApi(deactivateResult, ResponsePojo.class); return response.getResponse().isSuccess(); } catch (Exception e) { e.printStackTrace(); } return false; } ////////////////////////////////////////////////////////////////////////////////////////////// // SOCIAL - COMMUNITIES /** * createCommunity * @param communityName * @param communityDesc * @param communityTag * @param responsePojo * @return CommunityPojo */ public CommunityPojo createCommunity(String communityName, String communityDesc, String communityTags, String parentid, ResponseObject responseObject) { try { String createCommunityAddress = apiRoot + "social/community/add/" + URLEncoder.encode(communityName, "UTF-8") + "/" + URLEncoder.encode(communityDesc, "UTF-8") + "/" + URLEncoder.encode(communityTags, "UTF-8"); if (null != parentid) createCommunityAddress += "/" + URLEncoder.encode(parentid, "UTF-8"); String communityresult = sendRequest(createCommunityAddress, null); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(communityresult, ResponsePojo.class, CommunityPojo.class, new CommunityPojoApiMap()); ResponseObject internal_ro = internal_responsePojo.getResponse(); responseObject = shallowCopy(responseObject, internal_ro); return (CommunityPojo) internal_responsePojo.getData(); } catch (Exception e) { e.printStackTrace(); } return null; } public String addToCommunity(String communityId, String personId, ResponseObject responseObject) { try { String addToCommunityAddress = apiRoot + "social/community/member/invite/" + URLEncoder.encode(communityId, "UTF-8") + "/" + URLEncoder.encode(personId, "UTF-8") + "/"; String inviteresult = sendRequest(addToCommunityAddress, null); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(inviteresult, ResponsePojo.class, CommunityPojo.class, new CommunityPojoApiMap()); ResponseObject internal_ro = internal_responsePojo.getResponse(); responseObject = shallowCopy(responseObject, internal_ro); return responseObject.getMessage(); } catch (Exception e) { e.printStackTrace(); } return null; } public String joinCommunity(String communityId, ResponseObject responseObject) { try { String addToCommunityAddress = apiRoot + "social/community/member/join/" + URLEncoder.encode(communityId, "UTF-8"); String inviteresult = sendRequest(addToCommunityAddress, null); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(inviteresult, ResponsePojo.class, CommunityPojo.class, new CommunityPojoApiMap()); ResponseObject internal_ro = internal_responsePojo.getResponse(); responseObject = shallowCopy(responseObject, internal_ro); return responseObject.getMessage(); } catch (Exception e) { e.printStackTrace(); } return null; } public String forcefullyAddToCommunity(String communityId, String personId, ResponseObject responseObject) { try { String addToCommunityAddress = apiRoot + "social/community/member/invite/" + URLEncoder.encode(communityId, "UTF-8") + "/" + URLEncoder.encode(personId, "UTF-8") + "/?skipinvitation=true"; String inviteresult = sendRequest(addToCommunityAddress, null); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(inviteresult, ResponsePojo.class, CommunityPojo.class, new CommunityPojoApiMap()); ResponseObject internal_ro = internal_responsePojo.getResponse(); responseObject = shallowCopy(responseObject, internal_ro); return responseObject.getMessage(); } catch (Exception e) { e.printStackTrace(); } return null; } public CommunityPojo getCommunity(String communityIdentifier, ResponseObject responseObject) { try { String getCommunityAddress = apiRoot + "social/community/get/" + URLEncoder.encode(communityIdentifier, "UTF-8") + ""; String getResult = sendRequest(getCommunityAddress, null); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(getResult, ResponsePojo.class, CommunityPojo.class, new CommunityPojoApiMap()); ResponseObject internal_ro = internal_responsePojo.getResponse(); responseObject = shallowCopy(responseObject, internal_ro); return (CommunityPojo) internal_responsePojo.getData(); } catch (Exception e) { e.printStackTrace(); } return null; } public List<CommunityPojo> getPublicCommunities(ResponseObject responseObject) { try { String getCommunityAddress = apiRoot + "social/community/getpublic"; String getResult = sendRequest(getCommunityAddress, null); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(getResult, ResponsePojo.class); ResponseObject internal_ro = internal_responsePojo.getResponse(); responseObject = shallowCopy(responseObject, internal_ro); List<CommunityPojo> communities = null; communities = ApiManager.mapListFromApi((JsonElement) internal_responsePojo.getData(), CommunityPojo.listType(), null); return communities; } catch (Exception e) { responseObject.setSuccess(false); responseObject.setMessage(e.getMessage()); } return null; } public List<CommunityPojo> getAllCommunity(ResponseObject responseObject) { try { String getCommunityAddress = apiRoot + "social/community/getall"; String getResult = sendRequest(getCommunityAddress, null); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(getResult, ResponsePojo.class); ResponseObject internal_ro = internal_responsePojo.getResponse(); responseObject = shallowCopy(responseObject, internal_ro); List<CommunityPojo> communities = null; communities = ApiManager.mapListFromApi((JsonElement) internal_responsePojo.getData(), CommunityPojo.listType(), null); return communities; } catch (Exception e) { responseObject.setSuccess(false); responseObject.setMessage(e.getMessage()); } return null; } public Boolean deleteCommunity(String communityId, ResponseObject responseObject) { try { String addToCommunityAddress = apiRoot + "social/community/remove/" + URLEncoder.encode(communityId, "UTF-8"); String inviteresult = sendRequest(addToCommunityAddress, null); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(inviteresult, ResponsePojo.class); ResponseObject internal_ro = internal_responsePojo.getResponse(); responseObject = shallowCopy(responseObject, internal_ro); return responseObject.isSuccess(); } catch (Exception e) { e.printStackTrace(); } return null; } public Boolean updateCommunity(String communityId, CommunityPojo communityPojo, ResponseObject responseObject) { try { String addToCommunityAddress = apiRoot + "social/community/update/" + URLEncoder.encode(communityId, "UTF-8"); String updateResult = sendRequest(addToCommunityAddress, new Gson().toJson(communityPojo)); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(updateResult, ResponsePojo.class); ResponseObject internal_ro = internal_responsePojo.getResponse(); responseObject = shallowCopy(responseObject, internal_ro); return responseObject.isSuccess(); } catch (Exception e) { e.printStackTrace(); } return false; } public Boolean updateCommunityMemberType(String communityId, String personId, String userType, ResponseObject responseObject) { try { String updateCommunityMemberUrl = apiRoot + "social/community/member/update/type/" + URLEncoder.encode(communityId, "UTF-8") + "/" + URLEncoder.encode(personId, "UTF-8") + "/" + URLEncoder.encode(userType, "UTF-8"); String updateResult = sendRequest(updateCommunityMemberUrl, null); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(updateResult, ResponsePojo.class); ResponseObject internal_ro = internal_responsePojo.getResponse(); responseObject = shallowCopy(responseObject, internal_ro); return responseObject.isSuccess(); } catch (Exception e) { e.printStackTrace(); } return false; } public Boolean updateCommunityMemberStatus(String communityId, String personId, String userStatus, ResponseObject responseObject) { try { String updateCommunityMemberUrl = apiRoot + "social/community/member/update/status/" + URLEncoder.encode(communityId, "UTF-8") + "/" + URLEncoder.encode(personId, "UTF-8") + "/" + URLEncoder.encode(userStatus, "UTF-8"); String updateResult = sendRequest(updateCommunityMemberUrl, null); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(updateResult, ResponsePojo.class); ResponseObject internal_ro = internal_responsePojo.getResponse(); responseObject = shallowCopy(responseObject, internal_ro); return responseObject.isSuccess(); } catch (Exception e) { e.printStackTrace(); } return false; } ////////////////////////////////////////////////////////////////////////////////////////////// // SOCIAL - SHARES public List<SharePojo> searchShares(String searchCriteria, String searchString, String typeFilter, ResponseObject responseObject) { return searchShares(searchCriteria, searchString, typeFilter, false, responseObject); } //TESTED public List<SharePojo> searchShares(String searchCriteria, String searchString, String typeFilter, Boolean searchParent, ResponseObject responseObject) { try { StringBuffer url = new StringBuffer(apiRoot).append("social/share/search/"); if (null != searchCriteria) { url.append("?searchby=").append(searchCriteria).append("&id=") .append(URLEncoder.encode(searchString, "UTF-8")); } if (null != typeFilter) { if (null != searchCriteria) { url.append("&"); } else { url.append("?"); } url.append("type=").append(typeFilter); } if (searchParent) { if (null != searchCriteria && null != typeFilter) url.append("&"); else url.append("?"); url.append("searchParent=true"); } String deleteResult = sendRequest(url.toString(), null); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(deleteResult, ResponsePojo.class); ResponseObject internal_ro = internal_responsePojo.getResponse(); responseObject = shallowCopy(responseObject, internal_ro); List<SharePojo> shares = null; shares = ApiManager.mapListFromApi((JsonElement) internal_responsePojo.getData(), SharePojo.listType(), null); return shares; } catch (Exception e) { responseObject.setSuccess(false); responseObject.setMessage(e.getMessage()); } return null; } public SharePojo getShare(String shareId, ResponseObject responseObject) { try { String getShareAddress = apiRoot + "social/share/get/" + URLEncoder.encode(shareId, "UTF-8"); String getResult = sendRequest(getShareAddress, null); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(getResult, ResponsePojo.class, SharePojo.class, new SharePojoApiMap(null)); ResponseObject internal_ro = internal_responsePojo.getResponse(); responseObject = shallowCopy(responseObject, internal_ro); return (SharePojo) internal_responsePojo.getData(); } catch (Exception e) { e.printStackTrace(); } return null; } public SharePojo addShareJSON(String title, String description, String type, String jsonString, ResponseObject responseObject) { try { String addShareAddress = apiRoot + "social/share/add/json/" + URLEncoder.encode(type, "UTF-8") + "/" + URLEncoder.encode(title, "UTF-8") + "/" + URLEncoder.encode(description, "UTF-8"); String addResult = sendRequest(addShareAddress, jsonString); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(addResult, ResponsePojo.class, SharePojo.class, new SharePojoApiMap(null)); ResponseObject internal_ro = internal_responsePojo.getResponse(); responseObject = shallowCopy(responseObject, internal_ro); return (SharePojo) internal_responsePojo.getData(); } catch (Exception e) { e.printStackTrace(); } return null; } public Boolean updateShareJSON(String shareId, String title, String description, String type, String jsonString, ResponseObject responseObject) { try { String updateShareAddress = apiRoot + "social/share/update/json/" + shareId + "/" + URLEncoder.encode(type, "UTF-8") + "/" + URLEncoder.encode(title, "UTF-8") + "/" + URLEncoder.encode(description, "UTF-8"); String updateResult = sendRequest(updateShareAddress, jsonString); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(updateResult, ResponsePojo.class); ResponseObject internal_ro = internal_responsePojo.getResponse(); responseObject = shallowCopy(responseObject, internal_ro); return responseObject.isSuccess(); } catch (Exception e) { e.printStackTrace(); } return false; } public Boolean removeShare(String shareId, ResponseObject responseObject) { try { String removeShareAddress = apiRoot + "social/share/remove/" + URLEncoder.encode(shareId, "UTF-8"); String updateResult = sendRequest(removeShareAddress, null); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(updateResult, ResponsePojo.class); ResponseObject internal_ro = internal_responsePojo.getResponse(); responseObject = shallowCopy(responseObject, internal_ro); return responseObject.isSuccess(); } catch (Exception e) { e.printStackTrace(); } return false; } public Boolean addShareToCommunity(String shareId, String comment, String communityId, ResponseObject responseObject) { try { String addCommunityAddress = apiRoot + "social/share/add/community/" + shareId + "/" + URLEncoder.encode(comment, "UTF-8") + "/" + URLEncoder.encode(communityId, "UTF-8"); String updateResult = sendRequest(addCommunityAddress, null); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(updateResult, ResponsePojo.class); ResponseObject internal_ro = internal_responsePojo.getResponse(); responseObject = shallowCopy(responseObject, internal_ro); return responseObject.isSuccess(); } catch (Exception e) { e.printStackTrace(); } return false; } public Boolean removeShareFromCommunity(String shareId, String communityId, ResponseObject responseObject) { try { String addCommunityAddress = apiRoot + "social/share/remove/community/" + shareId + "/" + URLEncoder.encode(communityId, "UTF-8"); String updateResult = sendRequest(addCommunityAddress, null); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(updateResult, ResponsePojo.class); ResponseObject internal_ro = internal_responsePojo.getResponse(); responseObject = shallowCopy(responseObject, internal_ro); return responseObject.isSuccess(); } catch (Exception e) { e.printStackTrace(); } return false; } ////////////////////////////////////////////////////////////////////////////////////////////// // SOCIAL - PEOPLE public String deletePerson(String personId, ResponseObject responseObject) { try { String deletePersonAddress = apiRoot + "social/person/delete/" + URLEncoder.encode(personId, "UTF-8"); String deleteResult = sendRequest(deletePersonAddress, null); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(deleteResult, ResponsePojo.class); ResponseObject internal_ro = internal_responsePojo.getResponse(); responseObject = shallowCopy(responseObject, internal_ro); return responseObject.getMessage(); } catch (Exception e) { e.printStackTrace(); } return null; } /** * getPerson * @param personId Can be the person id, email address, or Null. If Null, it will return information about current user. * @param responsePojo * @return PersonPojo */ public PersonPojo getPerson(String personId, ResponseObject responseObject) { try { String getPersonAddress = apiRoot + "social/person/get"; if (personId != null) getPersonAddress += "/" + URLEncoder.encode(personId, "UTF-8"); String getResult = sendRequest(getPersonAddress, null); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(getResult, ResponsePojo.class, PersonPojo.class, new PersonPojoApiMap()); ResponseObject internal_ro = internal_responsePojo.getResponse(); responseObject = shallowCopy(responseObject, internal_ro); return (PersonPojo) internal_responsePojo.getData(); } catch (Exception e) { e.printStackTrace(); } return null; } /** * listPerson * * @param responseObject * @return */ public List<PersonPojo> listPerson(ResponseObject responseObject) { try { String listPersonAddress = apiRoot + "social/person/list"; String getResult = sendRequest(listPersonAddress, null); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(getResult, ResponsePojo.class); ResponseObject internal_ro = internal_responsePojo.getResponse(); responseObject = shallowCopy(responseObject, internal_ro); List<PersonPojo> people = null; people = ApiManager.mapListFromApi((JsonElement) internal_responsePojo.getData(), PersonPojo.listType(), new PersonPojoApiMap()); return people; } catch (Exception e) { e.printStackTrace(); } return null; } public String registerPerson(String first_name, String last_name, String phone, String email, String password, String accountType, ResponseObject responseObject) { try { Date date = new Date(); SimpleDateFormat formatter = new SimpleDateFormat("MMM dd, yyyy kk:mm:ss aa"); String today = formatter.format(date); String encrypted_password; encrypted_password = encryptWithoutEncode(password); WordPressUserPojo wpuser = new WordPressUserPojo(); WordPressAuthPojo wpauth = new WordPressAuthPojo(); wpuser.setCreated(today); wpuser.setModified(today); wpuser.setFirstname(first_name); wpuser.setLastname(last_name); wpuser.setPhone(phone); ArrayList<String> emailArray = new ArrayList<String>(); emailArray.add(email); wpuser.setEmail(emailArray); //wpauth.setWPUserID(email); wpauth.setPassword(encrypted_password); wpauth.setAccountType(accountType); wpauth.setCreated(today); wpauth.setModified(today); WordPressSetupPojo wpSetup = new WordPressSetupPojo(); wpSetup.setAuth(wpauth); wpSetup.setUser(wpuser); return registerPerson(wpSetup, responseObject); } catch (NoSuchAlgorithmException e) { e.printStackTrace(); } catch (UnsupportedEncodingException e) { e.printStackTrace(); } return null; } public String registerPerson(WordPressSetupPojo wpSetup, ResponseObject responseObject) { String theUrl = apiRoot + "social/person/register"; String data = new Gson().toJson(wpSetup); String registerResult = sendRequest(theUrl, data); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(registerResult, ResponsePojo.class); ResponseObject internal_ro = internal_responsePojo.getResponse(); responseObject = shallowCopy(responseObject, internal_ro); return responseObject.getMessage(); } public String updatePerson(String first_name, String last_name, String phone, String email, String password, String accountType, ResponseObject responseObject) { try { Date date = new Date(); SimpleDateFormat formatter = new SimpleDateFormat("MMM dd, yyyy kk:mm:ss aa"); String today = formatter.format(date); String encrypted_password = null; if (password != null) encrypted_password = encryptWithoutEncode(password); WordPressUserPojo wpuser = new WordPressUserPojo(); WordPressAuthPojo wpauth = new WordPressAuthPojo(); wpuser.setModified(today); wpuser.setFirstname(first_name); wpuser.setLastname(last_name); wpuser.setPhone(phone); ArrayList<String> emailArray = new ArrayList<String>(); emailArray.add(email); wpuser.setEmail(emailArray); wpauth.setWPUserID(email); wpauth.setPassword(encrypted_password); wpauth.setAccountType(accountType); wpauth.setModified(today); return updatePerson(wpuser, wpauth, responseObject); } catch (NoSuchAlgorithmException e) { e.printStackTrace(); } catch (UnsupportedEncodingException e) { e.printStackTrace(); } return null; } public String updatePerson(WordPressUserPojo wpuser, WordPressAuthPojo wpauth, ResponseObject responseObject) { String theUrl = apiRoot + "social/person/update"; String data = "{ \"user\":" + new Gson().toJson(wpuser) + ", \"auth\":" + new Gson().toJson(wpauth) + "}"; String updateResult = sendRequest(theUrl, data); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(updateResult, ResponsePojo.class); ResponseObject internal_ro = internal_responsePojo.getResponse(); responseObject = shallowCopy(responseObject, internal_ro); return responseObject.getMessage(); } public String updatePersonPassword(String id, String newPassword, ResponseObject responseObject) { try { String updatePasswordAddress = apiRoot + "social/person/update/password/" + URLEncoder.encode(id, "UTF-8") + "/" + URLEncoder.encode(newPassword, "UTF-8"); String updateResult = sendRequest(updatePasswordAddress, null); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(updateResult, ResponsePojo.class); ResponseObject internal_ro = internal_responsePojo.getResponse(); responseObject = shallowCopy(responseObject, internal_ro); return responseObject.getMessage(); } catch (Exception e) { e.printStackTrace(); } return ""; } ////////////////////////////////////////////////////////////////////////////////////////////// // CONFIG - SOURCE public SourcePojo getSource(String sourceId, ResponseObject responseObject) { try { String getSourceAddress = apiRoot + "config/source/get/" + URLEncoder.encode(sourceId, "UTF-8"); String getResult = sendRequest(getSourceAddress, null); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(getResult, ResponsePojo.class, SourcePojo.class, new SourcePojoApiMap(null)); ResponseObject internal_ro = internal_responsePojo.getResponse(); responseObject = shallowCopy(responseObject, internal_ro); return (SourcePojo) internal_responsePojo.getData(); } catch (Exception e) { e.printStackTrace(); } return null; } public SourcePojo saveSource(SourcePojo source, String communityId, ResponseObject responseObject) { try { String address = apiRoot + "config/source/save/" + communityId + "/"; String saveResult; saveResult = sendRequest(address, new Gson().toJson(source)); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(saveResult, ResponsePojo.class, SourcePojo.class, new SourcePojoApiMap(null)); ResponseObject internal_ro = internal_responsePojo.getResponse(); responseObject = shallowCopy(responseObject, internal_ro); return (SourcePojo) internal_responsePojo.getData(); } catch (Exception e) { e.printStackTrace(); } return null; } public String deleteSource(String sourceId, String communityId, ResponseObject responseObject) { try { String address = apiRoot + "config/source/delete/" + sourceId + "/" + communityId; String deleteResult = sendRequest(address, null); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(deleteResult, ResponsePojo.class); ResponseObject internal_ro = internal_responsePojo.getResponse(); responseObject = shallowCopy(responseObject, internal_ro); return responseObject.getMessage(); } catch (Exception e) { e.printStackTrace(); } return null; } public List<DocumentPojo> testSource(SourcePojo testSrc, ResponseObject response, int nToReturn, boolean bReturnFullText) { StringBuffer theUrl = new StringBuffer(apiRoot).append("config/source/test"); if (nToReturn > 0) { theUrl.append("?numReturn=").append(nToReturn); } if (bReturnFullText) { if (nToReturn > 0) { theUrl.append('&'); } else { theUrl.append('?'); } theUrl.append("returnFullText=true"); } String map = ApiManager.mapToApi(testSrc, null); String testResult = sendRequest(theUrl.toString(), map); ResponsePojo internal_response = ResponsePojo.fromApi(testResult, ResponsePojo.class); shallowCopy(response, internal_response.getResponse()); List<DocumentPojo> docs = null; if (response.isSuccess()) { docs = ApiManager.mapListFromApi((JsonElement) internal_response.getData(), DocumentPojo.listType(), new DocumentPojoApiMap()); } return docs; } ////////////////////////////////////////////////////////////////////////////////////////////// // KNOWLEDGE - QUERY // Queries are slightly different - the entire ResponsePojo is used. public ResponsePojo sendQuery(AdvancedQueryPojo query, ObjectId communityId, ResponseObject response) { ArrayList<ObjectId> community = new ArrayList<ObjectId>(1); community.add(communityId); return sendQuery(query, community, response); } public ResponsePojo sendQuery(AdvancedQueryPojo query, Collection<ObjectId> communities, ResponseObject response) { StringBuffer theUrl = new StringBuffer(apiRoot).append("knowledge/document/query/"); boolean bFirstComm = true; for (ObjectId commId : communities) { if (!bFirstComm) theUrl.append(','); theUrl.append(commId.toString()); bFirstComm = false; } String testResult = sendRequest(theUrl.toString(), query.toApi()); ResponsePojo internal_response = ResponsePojo.fromApi(testResult, ResponsePojo.class); shallowCopy(response, internal_response.getResponse()); return internal_response; } ////////////////////////////////////////////////////////////////////////////////////////////// // KNOWLEDGE - DOCUMENT - GET public DocumentPojo getDocument(String docid, ResponseObject responseObject) { return getDocument(docid, false, false, responseObject); } public DocumentPojo getDocument(String docid, boolean returnFullText, boolean returnRawData, ResponseObject responseObject) { try { StringBuffer theUrl = new StringBuffer(apiRoot).append("knowledge/document/get/"); theUrl.append(docid); theUrl.append("?returnFullText=").append(returnFullText); theUrl.append("?returnRawData=").append(returnRawData); String getResult = sendRequest(theUrl.toString(), null); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(getResult, ResponsePojo.class, DocumentPojo.class, new DocumentPojoApiMap()); ResponseObject internal_ro = internal_responsePojo.getResponse(); responseObject = shallowCopy(responseObject, internal_ro); return (DocumentPojo) internal_responsePojo.getData(); } catch (Exception ex) { ex.printStackTrace(); } return null; } public DocumentPojo getDocument(String sourceKey, String url, ResponseObject responseObject) { return getDocument(sourceKey, url, false, false, responseObject); } public DocumentPojo getDocument(String sourceKey, String url, boolean returnFullText, boolean returnRawData, ResponseObject responseObject) { try { StringBuffer theUrl = new StringBuffer(apiRoot).append("knowledge/document/get/"); theUrl.append(sourceKey).append("/").append(url); theUrl.append("?returnFullText=").append(returnFullText); theUrl.append("?returnRawData=").append(returnRawData); String getResult = sendRequest(theUrl.toString(), null); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(getResult, ResponsePojo.class, DocumentPojo.class, new DocumentPojoApiMap()); ResponseObject internal_ro = internal_responsePojo.getResponse(); responseObject = shallowCopy(responseObject, internal_ro); return (DocumentPojo) internal_responsePojo.getData(); } catch (Exception ex) { ex.printStackTrace(); } return null; } ////////////////////////////////////////////////////////////////////////////////////////////// // CUSTOM - CREATE PLUGIN TASK // The following fields of taskConfig are filled in (string unless otherwise specified): // - jobtitle, jobdesc // - jarURL: the name of the JAR in the share // - inputCollection // - firstSchedule (Date) ... when it will be run // - scheduleFreq (SCHEDULE_FREQUENCY) // - mapper, combiner, reducer // - outputKey, outputValue // - appendResult, ageOutInDays // - jobDependencies ... though using the input param that allows them to be specified as jobtitles is recommended public ObjectId createCustomPluginTask(CustomMapReduceJobPojo taskConfig, Collection<String> dependencies, ObjectId communityId, ResponseObject response) { ArrayList<ObjectId> community = new ArrayList<ObjectId>(1); community.add(communityId); return createCustomPluginTask(taskConfig, dependencies, community, response); } public ObjectId createCustomPluginTask(CustomMapReduceJobPojo taskConfig, Collection<String> dependencies, Collection<ObjectId> communities, ResponseObject response) { return createCustomPluginTask(taskConfig, dependencies, communities, response, false); } private ObjectId createCustomPluginTask(CustomMapReduceJobPojo taskConfig, Collection<String> dependencies, Collection<ObjectId> communities, ResponseObject response, boolean bUpdate) { ObjectId retVal = null; try { StringBuffer url = new StringBuffer(apiRoot).append("custom/mapreduce/"); if (bUpdate) { if (taskConfig._id != null) { url.append("updatejob/").append(taskConfig._id.toString()).append("/"); } else { url.append("updatejob/").append(taskConfig.jobtitle).append("/"); taskConfig.jobtitle = null; } //TESTED } else { url.append("schedulejob/"); } if (null != communities) { for (ObjectId communityId : communities) { url.append(communityId.toString()).append(','); } url.setLength(url.length() - 1); } else { url.append("null"); } url.append('/'); if ((null != taskConfig.jobDependencies) && !taskConfig.jobDependencies.isEmpty()) { for (ObjectId jobId : taskConfig.jobDependencies) { url.append(jobId.toString()).append(','); } url.setLength(url.length() - 1); } else if ((null != dependencies) && !dependencies.isEmpty()) { for (String jobTitle : dependencies) { url.append(jobTitle).append(','); } url.setLength(url.length() - 1); } else { url.append("null"); } url.append("/"); // "nextRunTime"==first Schedule (date) if (null != taskConfig.firstSchedule) { taskConfig.nextRunTime = taskConfig.firstSchedule.getTime(); } String json = sendRequest(url.toString(), ApiManager.mapToApi(taskConfig, null)); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(json, ResponsePojo.class); ResponseObject internal_ro = internal_responsePojo.getResponse(); response = shallowCopy(response, internal_ro); if (response.isSuccess()) { JsonPrimitive retValObj = (JsonPrimitive) internal_responsePojo.getData(); retVal = new ObjectId(retValObj.getAsString()); } } catch (Exception e) { response.setSuccess(false); response.setMessage(e.getMessage()); } return retVal; } //TESTED (one minor clause to test, will leave for now) /////////////////////////////////////////////////////////////////// // Updates ... as above but jobtitle or _id must be specified public ObjectId updateCustomPluginTask(CustomMapReduceJobPojo taskConfig, Collection<String> dependencies, ObjectId communityId, ResponseObject response) { ArrayList<ObjectId> community = new ArrayList<ObjectId>(1); community.add(communityId); return updateCustomPluginTask(taskConfig, dependencies, community, response); } public ObjectId updateCustomPluginTask(CustomMapReduceJobPojo taskConfig, Collection<String> dependencies, Collection<ObjectId> communities, ResponseObject response) { return createCustomPluginTask(taskConfig, dependencies, communities, response, true); } //TESTED ////////////////////////////////////////////////////////////////////////////////////////////// // CUSTOM - CREATE PLUGIN TASK // The following fields of taskConfig are filled in (string unless otherwise specified): // - jobtitle, jobdesc // - firstSchedule (Date) ... when it will be run // - scheduleFreq (SCHEDULE_FREQUENCY) // - appendResult, ageOutInDays public ObjectId createCustomSavedQueryTask(CustomMapReduceJobPojo taskConfig, AdvancedQueryPojo query, ObjectId communityId, ResponseObject response) { ArrayList<ObjectId> community = new ArrayList<ObjectId>(1); community.add(communityId); return createCustomSavedQueryTask(taskConfig, query, community, response); } public ObjectId createCustomSavedQueryTask(CustomMapReduceJobPojo taskConfig, ObjectId communityId, ResponseObject response) { ArrayList<ObjectId> community = new ArrayList<ObjectId>(1); community.add(communityId); return createCustomSavedQueryTask(taskConfig, null, community, response); } public ObjectId createCustomSavedQueryTask(CustomMapReduceJobPojo taskConfig, AdvancedQueryPojo query, Collection<ObjectId> communities, ResponseObject response) { if (null != query) { taskConfig.query = query.toApi(); } return createCustomPluginTask(taskConfig, null, communities, response); } //TESTED /////////////////////////////////////////////////////////////////// // Updates ... as above but jobtitle or _id must be specified public ObjectId updateCustomSavedQueryTask(CustomMapReduceJobPojo taskConfig, AdvancedQueryPojo query, ObjectId communityId, ResponseObject response) { ArrayList<ObjectId> community = new ArrayList<ObjectId>(1); community.add(communityId); return updateCustomSavedQueryTask(taskConfig, query, community, response); } public ObjectId updateCustomSavedQueryTask(CustomMapReduceJobPojo taskConfig, ObjectId communityId, ResponseObject response) { ArrayList<ObjectId> community = new ArrayList<ObjectId>(1); community.add(communityId); return updateCustomPluginTask(taskConfig, null, community, response); } public ObjectId updateCustomSavedQueryTask(CustomMapReduceJobPojo taskConfig, AdvancedQueryPojo query, Collection<ObjectId> communities, ResponseObject response) { if (null != query) { taskConfig.query = query.toApi(); } return updateCustomPluginTask(taskConfig, null, communities, response); } //TESTED public CustomMapReduceResultPojo getCustomTaskOrQueryResults(String jobtitle, ResponseObject response) { CustomMapReduceResultPojo retVal = null; try { StringBuilder url = new StringBuilder(apiRoot).append("custom/mapreduce/getresults/"); if (null != jobtitle) { url.append(jobtitle); } String json = sendRequest(url.toString(), null); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(json, ResponsePojo.class, CustomMapReduceResultPojo.class, new CustomMapReduceResultPojoApiMap()); ResponseObject internal_ro = internal_responsePojo.getResponse(); response = shallowCopy(response, internal_ro); if (response.isSuccess()) { //JsonElement js = (JsonElement)internal_responsePojo.getData(); //retVal = ApiManager.mapFromApi(js, CustomMapReduceResultPojo.class, null); retVal = (CustomMapReduceResultPojo) internal_responsePojo.getData(); } } catch (Exception e) { response.setSuccess(false); response.setMessage(e.getMessage()); } return retVal; } ////////////////////////////////////////////////////////////////////////////////////////////// public List<CustomMapReduceJobPojo> getCustomTaskOrQuery(String jobtitle, ResponseObject response) { List<CustomMapReduceJobPojo> retVal = null; try { StringBuilder url = new StringBuilder(apiRoot).append("custom/mapreduce/getjobs/"); if (null != jobtitle) { url.append(jobtitle); } // (else get all) String json = sendRequest(url.toString(), null); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(json, ResponsePojo.class); ResponseObject internal_ro = internal_responsePojo.getResponse(); response = shallowCopy(response, internal_ro); if (response.isSuccess()) { retVal = ApiManager.mapListFromApi((JsonElement) internal_responsePojo.getData(), CustomMapReduceJobPojo.listType(), null); } } catch (Exception e) { response.setSuccess(false); response.setMessage(e.getMessage()); } return retVal; } ////////////////////////////////////////////////////////////////////////////////////////////// // And deletes, apply to either: public boolean deleteCustomTaskOrQuery(String jobtitle, ResponseObject response) { try { StringBuilder url = new StringBuilder(apiRoot).append("custom/mapreduce/removejob/"); url.append(jobtitle); String json = sendRequest(url.toString(), null); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(json, ResponsePojo.class); ResponseObject internal_ro = internal_responsePojo.getResponse(); response = shallowCopy(response, internal_ro); } catch (Exception e) { response.setSuccess(false); response.setMessage(e.getMessage()); } return response.isSuccess(); } public boolean deleteCustomTaskOrQuery(ObjectId taskId, ResponseObject response) { return deleteCustomTaskOrQuery(taskId.toString(), response); } //TESTED ////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////// // ALIASES // UPDATE, REMOVE, AND GET // This is not super-efficient code public Set<String> updateAliases(Collection<EntityFeaturePojo> aliasesToUpdate, String communityIdStr, boolean bUpsert, ResponseObject response) { return updateAliases(aliasesToUpdate, communityIdStr, bUpsert, null, response); } public Set<String> removeAliases(Collection<String> aliasesToRemove, String communityIdStr, ResponseObject response) { return removeAliases(aliasesToRemove, communityIdStr, null, response); } // (Only use this version if immediately called after getAliases since none of this is in any way atomic) public Set<String> updateAliases(Collection<EntityFeaturePojo> aliasesToUpdate, String communityIdStr, boolean bUpsert, Map<String, List<SharePojo>> aliasMapping, ResponseObject response) { if (null == aliasMapping) { aliasMapping = new HashMap<String, List<SharePojo>>(); this.getAliases(communityIdStr, aliasMapping, response); if (!response.isSuccess()) { return null; } } //TESTED Map<ObjectId, BasicDBObject> shareContentCache = new HashMap<ObjectId, BasicDBObject>(); List<SharePojo> sharesToUpdate = new LinkedList<SharePojo>(); // Step through the aliases, update the content // Loop 1 update SharePojo shareForNewAliases = null; Set<String> erroredAliases = new HashSet<String>(); HashMultimap<ObjectId, String> shareToAliasMapping = HashMultimap.create(); for (EntityFeaturePojo alias : aliasesToUpdate) { List<SharePojo> sharesForThisAlias = aliasMapping.get(alias.getIndex()); if ((null == sharesForThisAlias) && bUpsert) { // This is a new alias and not ignoring upserts if (null == shareForNewAliases) { // Haven't yet assigned such a share shareForNewAliases = this.upsertSharePrep(communityIdStr, shareContentCache, aliasMapping); if (null == shareForNewAliases) { erroredAliases.add(alias.getIndex()); continue; } sharesToUpdate.add(shareForNewAliases); } BasicDBObject shareContent = shareContentCache.get(shareForNewAliases.get_id()); // (exists by construction) shareContent.put(alias.getIndex(), alias.toDb()); shareToAliasMapping.put(shareForNewAliases.get_id(), alias.getIndex()); } //TESTED else if (null != sharesForThisAlias) { for (SharePojo share : sharesForThisAlias) { BasicDBObject shareContent = shareContentCache.get(share.get_id()); if (null == shareContent) { try { String json = share.getShare(); shareContent = (BasicDBObject) JSON.parse(json); shareContentCache.put(share.get_id(), shareContent); sharesToUpdate.add(share); } catch (Exception e) { erroredAliases.add(alias.getIndex()); } } //TESTED shareContent.put(alias.getIndex(), alias.toDb()); shareToAliasMapping.put(share.get_id(), alias.getIndex()); } //TESTED } else { erroredAliases.add(alias.getIndex()); } // end loop over updating shares } //end loop over aliases // Loop 2 now update all the shares boolean bSucceededUpdatingSomething = false; for (SharePojo share : sharesToUpdate) { BasicDBObject shareContent = shareContentCache.get(share.get_id()); // (exists by construction) String shareIdStr = share.get_id().toString(); this.updateShareJSON(shareIdStr, share.getTitle(), share.getDescription(), "infinite-entity-alias", shareContent.toString(), response); bSucceededUpdatingSomething |= response.isSuccess(); if (!response.isSuccess()) { Set<String> failedAliases = shareToAliasMapping.get(share.get_id()); if (null != failedAliases) { erroredAliases.addAll(failedAliases); } } } //TESTED response.setSuccess(bSucceededUpdatingSomething); return erroredAliases; } // (Only use this version if immediately called after getAliases since none of this is in any way atomic) public Set<String> removeAliases(Collection<String> aliasesToRemove, String communityIdStr, Map<String, List<SharePojo>> aliasMapping, ResponseObject response) { if (null == aliasMapping) { aliasMapping = new HashMap<String, List<SharePojo>>(); this.getAliases(communityIdStr, aliasMapping, response); if (!response.isSuccess()) { return null; } } //TESTED Map<ObjectId, BasicDBObject> shareContentCache = new HashMap<ObjectId, BasicDBObject>(); List<SharePojo> sharesToUpdate = new LinkedList<SharePojo>(); // Step through the aliases, update the content // Loop 1 update Set<String> erroredAliases = new HashSet<String>(); HashMultimap<ObjectId, String> shareToAliasMapping = HashMultimap.create(); for (String alias : aliasesToRemove) { List<SharePojo> sharesForThisAlias = aliasMapping.get(alias); if (null != sharesForThisAlias) { for (SharePojo share : sharesForThisAlias) { BasicDBObject shareContent = shareContentCache.get(share.get_id()); if (null == shareContent) { try { String json = share.getShare(); shareContent = (BasicDBObject) JSON.parse(json); shareContentCache.put(share.get_id(), shareContent); sharesToUpdate.add(share); } catch (Exception e) { erroredAliases.add(alias); } } //TESTED shareContent.remove(alias); shareToAliasMapping.put(share.get_id(), alias); } //TESTED } // end loop over updating shares } //end loop over aliases // Loop 2 now update all the shares boolean bSucceededUpdatingSomething = false; for (SharePojo share : sharesToUpdate) { BasicDBObject shareContent = shareContentCache.get(share.get_id()); // (exists by construction) String shareIdStr = share.get_id().toString(); if (shareContent.isEmpty()) { // Remove the share this.removeShare(shareIdStr, response); if (!response.isSuccess()) { Set<String> failedAliases = shareToAliasMapping.get(share.get_id()); if (null != failedAliases) { erroredAliases.addAll(failedAliases); } } } //TESTED else { this.updateShareJSON(shareIdStr, share.getTitle(), share.getDescription(), "infinite-entity-alias", shareContent.toString(), response); bSucceededUpdatingSomething |= response.isSuccess(); if (!response.isSuccess()) { Set<String> failedAliases = shareToAliasMapping.get(share.get_id()); if (null != failedAliases) { erroredAliases.addAll(failedAliases); } } } //TESTED } //TESTED response.setSuccess(bSucceededUpdatingSomething); return erroredAliases; } // THIS IS BOTH PUBLIC AND A UTILITY FOR THE OTHER CALLS public Map<String, EntityFeaturePojo> getAliases(String communityIdStr, ResponseObject response) { return getAliases(communityIdStr, null, response); } public Map<String, EntityFeaturePojo> getAliases(String communityIdStr, Map<String, List<SharePojo>> aliasMapping, ResponseObject response) { // Get the shares with the right type and community List<SharePojo> shareList = this.searchShares("community", communityIdStr, "infinite-entity-alias", response); if (!response.isSuccess()) { return null; } // Generate a list HashMap<String, EntityFeaturePojo> masterAliases = new HashMap<String, EntityFeaturePojo>(); if (null != shareList) { for (SharePojo share : shareList) { populateAliasTableFromShare(share, masterAliases, aliasMapping); } } response.setSuccess(true); return masterAliases; }//TESTED // ALIAS UTILITIES: private SharePojo upsertSharePrep(String communityIdStr, Map<ObjectId, BasicDBObject> shareContentCache, Map<String, List<SharePojo>> aliasMapping) { SharePojo shareForNewAliases = null; BasicDBObject contentForNewAliases = null; for (List<SharePojo> shares : aliasMapping.values()) { if (!shares.isEmpty()) { shareForNewAliases = shares.iterator().next(); try { String json = shareForNewAliases.getShare(); contentForNewAliases = (BasicDBObject) JSON.parse(json); shareContentCache.put(shareForNewAliases.get_id(), contentForNewAliases); break; } catch (Exception e) { } // Try a different share } } //TESTED if (null == shareForNewAliases) { // Didn't find one, so going to have to create something EntityFeaturePojo discard = new EntityFeaturePojo(); discard.setDisambiguatedName("DISCARD"); discard.setType("SPECIAL"); discard.setIndex("DISCARD"); EntityFeaturePojo docDiscard = new EntityFeaturePojo(); docDiscard.setDisambiguatedName("DOCUMENT_DISCARD"); docDiscard.setType("SPECIAL"); docDiscard.setIndex("DOCUMENT_DISCARD"); contentForNewAliases = new BasicDBObject("DISCARD", discard.toDb()); contentForNewAliases.put("DOCUMENT_DISCARD", docDiscard); ResponseObject response = new ResponseObject(); shareForNewAliases = this.addShareJSON("Alias Share: " + communityIdStr, "An alias share for a specific community", "infinite-entity-alias", "{}", response); if ((null == shareForNewAliases) || !response.isSuccess()) { return null; } //TESTED // Remove share from personal community try { ShareCommunityPojo currCommunity = shareForNewAliases.getCommunities().iterator().next(); String removeCommunityIdStr = currCommunity.get_id().toString(); if (!communityIdStr.equals(removeCommunityIdStr)) { // (obv not if this is my community somehow, don't think that's possible) this.removeShareFromCommunity(shareForNewAliases.get_id().toString(), removeCommunityIdStr, response); if (!response.isSuccess()) { return null; } } } catch (Exception e) { } // do nothing I guess, not in any communities? this.addShareToCommunity(shareForNewAliases.get_id().toString(), "aliasComm", communityIdStr, response); if (!response.isSuccess()) { return null; } } //TESTED shareContentCache.put(shareForNewAliases.get_id(), contentForNewAliases); return shareForNewAliases; }//TESTED // THIS IS A SUBSET OF com.ikanow.infinit.e.api.knowledge.aliases.AliasLookupTable private void populateAliasTableFromShare(SharePojo share, HashMap<String, EntityFeaturePojo> masterAliases, Map<String, List<SharePojo>> aliasMapping) { String json = share.getShare(); if (null != json) { try { DBObject dbo = (DBObject) JSON.parse(json); if (null != dbo) { for (Object entryObj : dbo.toMap().entrySet()) { @SuppressWarnings("unchecked") Map.Entry<String, Object> entry = (Map.Entry<String, Object>) entryObj; String masterAlias = entry.getKey(); BasicDBObject entityFeatureObj = (BasicDBObject) entry.getValue(); EntityFeaturePojo aliasInfo = null; try { aliasInfo = EntityFeaturePojo.fromDb(entityFeatureObj, EntityFeaturePojo.class); } catch (Exception e) { continue; } if (null == aliasInfo.getIndex()) { aliasInfo.setIndex(masterAlias); } if (null != aliasInfo) { // (allow getAlias to be null/empty) //(overwrite duplicates) masterAliases.put(aliasInfo.getIndex(), aliasInfo); if (null != aliasMapping) { List<SharePojo> shareList = aliasMapping.get(aliasInfo.getIndex()); if (null == shareList) { shareList = new LinkedList<SharePojo>(); aliasMapping.put(aliasInfo.getIndex(), shareList); } shareList.add(share); } } } } } catch (Exception e) { } // not Json, just carry on... } }//TESTED public DimensionListPojo getEntitySuggest(String searchterm, String communityIdStr, boolean includeGeo, boolean includeLinkData, ResponseObject response) { try { StringBuilder url = new StringBuilder(apiRoot).append("knowledge/feature/entitySuggest/"); url.append(URLEncoder.encode(searchterm, "UTF-8")); url.append("/"); url.append(URLEncoder.encode(communityIdStr, "UTF-8")); String json = sendRequest(url.toString(), null); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(json, ResponsePojo.class); ResponseObject internal_ro = internal_responsePojo.getResponse(); response = shallowCopy(response, internal_ro); return new Gson().fromJson((JsonElement) internal_responsePojo.getData(), DimensionListPojo.class); } catch (Exception e) { response.setSuccess(false); response.setMessage(e.getMessage()); } return null; } public List<SearchSuggestPojo> getGeoSuggest(Double latitude, Double longitude, String communityIdStr, ResponseObject response) { List<SearchSuggestPojo> locations = null; try { String searchterm = latitude + "," + longitude; StringBuilder url = new StringBuilder(apiRoot).append("knowledge/feature/geoSuggest/"); url.append(URLEncoder.encode(searchterm, "UTF-8")); url.append("/"); url.append(URLEncoder.encode(communityIdStr, "UTF-8")); String json = sendRequest(url.toString(), null); ResponsePojo internal_responsePojo = ResponsePojo.fromApi(json, ResponsePojo.class); ResponseObject internal_ro = internal_responsePojo.getResponse(); response = shallowCopy(response, internal_ro); locations = ApiManager.mapListFromApi((JsonElement) internal_responsePojo.getData(), SearchSuggestPojo.listType(), null); } catch (Exception e) { response.setSuccess(false); response.setMessage(e.getMessage()); } return locations; } ////////////////////////////////////////////////////////////////////////////////////////////// // UTILITY public boolean hasSourceHarvested(String sourceId) { ResponseObject ro = new ResponseObject(); return hasSourceHarvested(getSource(sourceId, ro)); } public boolean hasSourceHarvested(SourcePojo source) { if (source != null) { if (source.getHarvestStatus() != null && source.getHarvestStatus().getHarvested() != null) { if (source.getHarvestStatus().getHarvest_status() == HarvestEnum.in_progress && source.getHarvestStatus().getDoccount() != null && source.getHarvestStatus().getDoccount() > 0) { //if the source is in progress but has a doc count, it has already completed once return true; } else if (source.getHarvestStatus().getHarvested() != null) { //if the source is not in progress but has a harvested date, it has completed atleast once return true; } } } return false; } public boolean isAdmin() { return this.sendKeepalive(true); } ///////// Request Calls public String sendRequest(String urlAddress, String postData) { try { if (postData == null) return sendGetRequest(urlAddress); else return sendPostRequest(urlAddress, postData); } catch (Exception e) { e.printStackTrace(); return ""; } } private String sendPostRequest(String urlAddress, String data) throws MalformedURLException, IOException { return sendPostRequest(urlAddress, data, 0); } private String sendPostRequest(String urlAddress, String data, int redirects) throws MalformedURLException, IOException { String result = ""; if (urlAddress.startsWith("https:")) { TrustManagerManipulator.allowAllSSL(); } URLConnection urlConnection = new URL(urlAddress).openConnection(); if (cookie != null) urlConnection.setRequestProperty("Cookie", cookie); if (apiKey != null) urlConnection.setRequestProperty("Cookie", apiKey); urlConnection.setDoOutput(true); urlConnection.setRequestProperty("Accept-Charset", "UTF-8"); ((HttpURLConnection) urlConnection).setRequestMethod("POST"); // Post JSON string to URL OutputStream os = urlConnection.getOutputStream(); byte[] b = data.getBytes("UTF-8"); os.write(b); int status = ((HttpURLConnection) urlConnection).getResponseCode(); // normally, 3xx is redirect if (status != HttpURLConnection.HTTP_OK) { if (status == HttpURLConnection.HTTP_MOVED_TEMP || status == HttpURLConnection.HTTP_MOVED_PERM || status == HttpURLConnection.HTTP_SEE_OTHER) { if (redirects <= 5) { String newUrlAddress = ((HttpURLConnection) urlConnection).getHeaderField("Location"); if (null != newUrlAddress) { return sendPostRequest(newUrlAddress, data, redirects + 1); } } //(else carry on, will exception out or something below) } } //TESTED // Receive results back from API InputStream inStream = urlConnection.getInputStream(); result = IOUtils.toString(inStream, "UTF-8"); inStream.close(); //save cookie if cookie is null if (cookie == null) { String headername; for (int i = 1; (headername = urlConnection.getHeaderFieldKey(i)) != null; i++) { if (headername.equals("Set-Cookie")) { cookie = urlConnection.getHeaderField(i); break; } } } return result; } public String sendGetRequest(String urlAddress) throws Exception { return sendGetRequest(urlAddress, 0); } public String sendGetRequest(String urlAddress, int redirects) throws Exception { if (urlAddress.startsWith("https:")) { TrustManagerManipulator.allowAllSSL(); } URL url = new URL(urlAddress); URLConnection urlConnection = url.openConnection(); if (cookie != null) urlConnection.setRequestProperty("Cookie", cookie); if (apiKey != null) urlConnection.setRequestProperty("Cookie", apiKey); ((HttpURLConnection) urlConnection).setRequestMethod("GET"); int status = ((HttpURLConnection) urlConnection).getResponseCode(); // normally, 3xx is redirect if (status != HttpURLConnection.HTTP_OK) { if (status == HttpURLConnection.HTTP_MOVED_TEMP || status == HttpURLConnection.HTTP_MOVED_PERM || status == HttpURLConnection.HTTP_SEE_OTHER) { if (redirects <= 5) { String newUrlAddress = ((HttpURLConnection) urlConnection).getHeaderField("Location"); if (null != newUrlAddress) { return sendGetRequest(newUrlAddress, redirects + 1); } } //(else carry on, will exception out or something below) } } //TESTED //read back result BufferedReader inStream = new BufferedReader(new InputStreamReader(urlConnection.getInputStream())); StringBuilder strBuilder = new StringBuilder(); String buffer; while ((buffer = inStream.readLine()) != null) { strBuilder.append(buffer); } inStream.close(); //save cookie if cookie is null if (cookie == null) { String headername; for (int i = 1; (headername = urlConnection.getHeaderFieldKey(i)) != null; i++) { if (headername.equals("Set-Cookie")) { cookie = urlConnection.getHeaderField(i); break; } } } return strBuilder.toString(); } ///////////Password Encryption public String encryptEncodePassword(String pword) throws UnsupportedEncodingException, NoSuchAlgorithmException { return URLEncoder.encode(encryptWithoutEncode(pword), "UTF-8"); } public static String encryptWithoutEncode(String password) throws NoSuchAlgorithmException, UnsupportedEncodingException { MessageDigest md = MessageDigest.getInstance("SHA-256"); md.update(password.getBytes("UTF-8")); return new String(Base64.encodeBase64(md.digest())); } //////////Shallow Copy Response Object private ResponseObject shallowCopy(ResponseObject toCopy, ResponseObject fromCopy) { toCopy.setAction(fromCopy.getAction()); toCopy.setMessage(fromCopy.getMessage()); toCopy.setSuccess(fromCopy.isSuccess()); toCopy.setTime(fromCopy.getTime()); return fromCopy; } /////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////// // Start of some test code // Run standalone RESTlet API on 8184 pointing to the right place // Invoke with username and password public static void main(String[] args) { if (args.length < 2) { System.out.println("*** CALL WITH username password as args"); System.exit(-1); } InfiniteDriver.setDefaultApiRoot("http://localhost:8184/"); InfiniteDriver infDriver = new InfiniteDriver(); ResponseObject responseObject = new ResponseObject(); infDriver.login(args[0], args[1], responseObject); System.out.println("DRIVER LOGIN = " + responseObject.isSuccess() + " : " + responseObject.getMessage()); List<PersonPojo> people = infDriver.listPerson(responseObject); System.out.println( "DRIVER LIST PEOPLE = " + responseObject.isSuccess() + " : " + responseObject.getMessage()); if (null != people) { System.out.println("FOUND " + people.size()); if (people.size() > 0) { System.out.println("EXAMPLE " + people.iterator().next().toDb()); } } } }