public List<CIBuild> getBuilds(CIJob job) throws PhrescoException {
if (debugEnabled) {
S_LOGGER.debug("Entering Method CIManagerImpl.getCIBuilds(CIJob job)");
}
List<CIBuild> ciBuilds = null;
try {
if (debugEnabled) {
S_LOGGER.debug("getCIBuilds() JobName = " + job.getName());
}
JsonArray jsonArray = getBuildsArray(job);
ciBuilds = new ArrayList<CIBuild>(jsonArray.size());
Gson gson = new Gson();
CIBuild ciBuild = null;
for (int i = 0; i < jsonArray.size(); i++) {
ciBuild = gson.fromJson(jsonArray.get(i), CIBuild.class);
setBuildStatus(ciBuild, job);
String buildUrl = ciBuild.getUrl();
String jenkinUrl = job.getJenkinsUrl() + ":" + job.getJenkinsPort();
buildUrl =
buildUrl.replaceAll(
"localhost:" + job.getJenkinsPort(),
jenkinUrl); // when displaying url it should display setup machine ip
ciBuild.setUrl(buildUrl);
ciBuilds.add(ciBuild);
}
} catch (Exception e) {
if (debugEnabled) {
S_LOGGER.debug(
"Entering Method CIManagerImpl.getCIBuilds(CIJob job) " + e.getLocalizedMessage());
}
}
return ciBuilds;
}
private void SetChatManager(JsonObject chat, JsonObject log) {
List<Line> chatMessages = new ArrayList<Line>();
List<Line> gameHistory = new ArrayList<Line>();
// Get chat info
{
JsonArray lines = chat.getAsJsonArray("lines");
for (int i = 0; i < lines.size(); i++) {
JsonObject line = lines.get(i).getAsJsonObject();
String message = line.getAsJsonPrimitive("message").getAsString();
String source = line.getAsJsonPrimitive("source").getAsString();
Line l = new Line(message, source);
chatMessages.add(l);
}
}
// Get log info
{
JsonArray lines = log.getAsJsonArray("lines");
for (int i = 0; i < lines.size(); i++) {
JsonObject line = lines.get(i).getAsJsonObject();
String message = line.getAsJsonPrimitive("message").getAsString();
String source = line.getAsJsonPrimitive("source").getAsString();
Line l = new Line(message, source);
gameHistory.add(l);
}
}
this.chatManager = new ChatManager(chatMessages, gameHistory);
}
private void SetPlayerManager(JsonArray players, JsonObject turnTracker) {
Player[] catanPlayers = new Player[players.size()];
int longestRoad = turnTracker.getAsJsonPrimitive("longestRoad").getAsInt();
int largestArmy = turnTracker.getAsJsonPrimitive("largestArmy").getAsInt();
for (int i = 0; i < players.size(); i++) {
if (!players.get(i).isJsonNull()) {
JsonObject player = players.get(i).getAsJsonObject();
int index = player.getAsJsonPrimitive("playerIndex").getAsInt();
String name = player.getAsJsonPrimitive("name").getAsString();
String color = player.getAsJsonPrimitive("color").getAsString();
int playerId = player.getAsJsonPrimitive("playerID").getAsInt();
int cities = player.getAsJsonPrimitive("cities").getAsInt();
int settlements = player.getAsJsonPrimitive("settlements").getAsInt();
int roads = player.getAsJsonPrimitive("roads").getAsInt();
int victoryPoints = player.getAsJsonPrimitive("victoryPoints").getAsInt();
Player newPlayer = new Player();
newPlayer.setPoints(victoryPoints);
try {
newPlayer.setColor(color);
} catch (InvalidColorException e) {
e.printStackTrace();
}
if (longestRoad == index) {
newPlayer.setLongestRoad(true);
}
if (largestArmy == index) {
newPlayer.setLargestArmy(true);
}
newPlayer.setId(playerId);
newPlayer.setCitiesRemaining(cities);
newPlayer.setSettlementsRemaining(settlements);
newPlayer.setRoadsRemaining(roads);
newPlayer.setPlayerIndex(index);
newPlayer.setName(name);
// <========Construct part of player manager here============>
catanPlayers[index] = newPlayer;
}
}
// <========Construct player manager here============>
PlayerManager newPlayerManager = new PlayerManager();
newPlayerManager.setCatanPlayers(catanPlayers);
newPlayerManager.setIndexOfLargestArmy(largestArmy);
newPlayerManager.setIndexOfLongestRoad(longestRoad);
this.playerManager = newPlayerManager;
}
public static SiebelPropertySet JsonObjectToPropertySet(JsonObject obj, SiebelPropertySet ps) {
Iterator<Entry<String, JsonElement>> iterator = obj.entrySet().iterator();
ps.setType("SiebelMessage");
SiebelPropertySet child;
while (iterator.hasNext()) {
JsonArray jsonArray = new JsonArray();
JsonObject jsonObject = new JsonObject();
Map.Entry mapEntry = (Map.Entry) iterator.next();
if (mapEntry != null) {
JsonElement jsonelement = (JsonElement) mapEntry.getValue();
if (jsonelement.isJsonArray()) {
jsonArray = jsonelement.getAsJsonArray();
child = new SiebelPropertySet();
child.setType("ListOf-" + mapEntry.getKey().toString());
for (int i = 0; i < jsonArray.size(); i++) {
if (jsonArray.get(i).isJsonObject() || jsonArray.get(i).isJsonArray()) {
SiebelPropertySet temp = new SiebelPropertySet();
temp.setType("" + i);
child.addChild(JsonObjectToPropertySet(jsonArray.get(i).getAsJsonObject(), temp));
} else child.setProperty("" + i, jsonArray.get(i).getAsString());
}
ps.addChild(child);
} else if (jsonelement.isJsonObject()) {
jsonObject = jsonelement.getAsJsonObject();
child = new SiebelPropertySet();
child.setType(mapEntry.getKey().toString());
ps.addChild(JsonObjectToPropertySet(jsonObject, child));
} else {
ps.setProperty(mapEntry.getKey().toString(), mapEntry.getValue().toString());
}
}
}
return ps;
}
private void parsePlugins(String context, QueryMetric queryMetric, JsonArray plugins)
throws BeanValidationException, QueryException {
for (int I = 0; I < plugins.size(); I++) {
JsonObject pluginJson = plugins.get(I).getAsJsonObject();
JsonElement name = pluginJson.get("name");
if (name == null || name.getAsString().isEmpty())
throw new BeanValidationException(
new SimpleConstraintViolation("plugins[" + I + "]", "must have a name"), context);
String pluginContext = context + ".plugins[" + I + "]";
String pluginName = name.getAsString();
QueryPlugin plugin = m_pluginFactory.createQueryPlugin(pluginName);
if (plugin == null)
throw new BeanValidationException(
new SimpleConstraintViolation(pluginName, "invalid query plugin name"), pluginContext);
deserializeProperties(pluginContext, pluginJson, pluginName, plugin);
validateObject(plugin, pluginContext);
queryMetric.addPlugin(plugin);
}
}
private void parseGroupBy(String context, QueryMetric queryMetric, JsonArray groupBys)
throws QueryException, BeanValidationException {
for (int J = 0; J < groupBys.size(); J++) {
String groupContext = "group_by[" + J + "]";
JsonObject jsGroupBy = groupBys.get(J).getAsJsonObject();
JsonElement nameElement = jsGroupBy.get("name");
if (nameElement == null || nameElement.getAsString().isEmpty())
throw new BeanValidationException(
new SimpleConstraintViolation(groupContext, "must have a name"), context);
String name = nameElement.getAsString();
GroupBy groupBy = m_groupByFactory.createGroupBy(name);
if (groupBy == null)
throw new BeanValidationException(
new SimpleConstraintViolation(groupContext + "." + name, "invalid group_by name"),
context);
deserializeProperties(context + "." + groupContext, jsGroupBy, name, groupBy);
validateObject(groupBy, context + "." + groupContext);
groupBy.setStartDate(queryMetric.getStartTime());
queryMetric.addGroupBy(groupBy);
}
}
private static void readJsonFile() {
try (JsonReader jsonReader =
Json.createReader(
new FileReader(
Paths.get(System.getProperty("user.dir"), "target/myData.json").toString()))) {
JsonStructure jsonStructure = jsonReader.read();
JsonValue.ValueType valueType = jsonStructure.getValueType();
if (valueType == JsonValue.ValueType.OBJECT) {
JsonObject jsonObject = (JsonObject) jsonStructure;
JsonValue firstName = jsonObject.get("firstName");
LOGGER.info("firstName=" + firstName);
JsonValue emailAddresses = jsonObject.get("phoneNumbers");
if (emailAddresses.getValueType() == JsonValue.ValueType.ARRAY) {
JsonArray jsonArray = (JsonArray) emailAddresses;
for (int i = 0; i < jsonArray.size(); i++) {
JsonValue jsonValue = jsonArray.get(i);
LOGGER.info("emailAddress(" + i + "): " + jsonValue);
}
}
} else {
LOGGER.warning("First object is not of type " + JsonValue.ValueType.OBJECT);
}
} catch (FileNotFoundException e) {
LOGGER.severe("Failed to open file: " + e.getMessage());
}
}
/**
* Parse a json message collection to create a Message
*
* @param arg json collection
* @return Message
*/
public static Message readMessage(String arg) {
JsonReader jsonReader = Json.createReader(new StringReader(arg));
JsonObject msgValues = jsonReader.readObject();
jsonReader.close();
if (null == msgValues.getJsonArray(ATTACHMENTS)) {
return new Message(
msgValues.getString(ID),
msgValues.getString(SENDER),
msgValues.getString(TOPIC),
msgValues.getJsonNumber(TIMESTAMP).longValue(),
msgValues.getString(CONTENT));
} else {
JsonArray attachmentsJson = msgValues.getJsonArray(ATTACHMENTS);
Byte[] attachmentByte = new Byte[attachmentsJson.size()];
for (int i = 0; i < attachmentByte.length; i++) {
attachmentByte[i] = Byte.valueOf(attachmentsJson.getString(i));
}
return new Message(
msgValues.getString(ID),
msgValues.getString(SENDER),
msgValues.getString(TOPIC),
msgValues.getJsonNumber(TIMESTAMP).longValue(),
msgValues.getString(CONTENT),
attachmentByte);
}
}
private ArrayList<String> getAppUsersId() {
// TODO: Fetch user ids from database
ArrayList<String> usersID = new ArrayList<String>();
try {
String response =
new GetUsersTask()
.execute("http://katanaserver.no-ip.org/gcm_server_php/get_users.php")
.get();
// Parse the response
JsonElement jelement = new JsonParser().parse(response);
JsonArray jarray = jelement.getAsJsonArray();
for (int i = 0; i < jarray.size(); i++) {
usersID.add(jarray.get(i).getAsJsonObject().get("UserID").toString());
}
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
return usersID;
}
public static Object gsonToPrimitive(JsonElement element) {
if (element.isJsonPrimitive()) {
JsonPrimitive prim = element.getAsJsonPrimitive();
if (prim.isString()) {
return prim.getAsString();
} else if (prim.isBoolean()) {
return prim.getAsBoolean();
} else if (prim.isNumber()) {
return prim.getAsNumber();
} else {
throw new IllegalArgumentException("Unknown Gson primitive: " + prim);
}
} else if (element.isJsonArray()) {
JsonArray array = element.getAsJsonArray();
List<Object> list = new ArrayList<Object>();
for (int i = 0; i < array.size(); i++) {
list.add(gsonToPrimitive(array.get(i)));
}
return list;
} else if (element.isJsonNull()) {
return null;
} else if (element.isJsonObject()) {
Map<String, Object> map = new HashMap<String, Object>();
for (Map.Entry<String, JsonElement> entry : element.getAsJsonObject().entrySet()) {
map.put(entry.getKey(), gsonToPrimitive(entry.getValue()));
}
return map;
} else {
throw new IllegalArgumentException("Unknown Gson value: " + element);
}
}
@Override
protected Response serve() {
JsonObject json = new JsonObject();
JsonArray succ = new JsonArray();
JsonArray fail = new JsonArray();
String bucket = _bucket.value();
AmazonS3 s3 = PersistS3.getClient();
ObjectListing currentList = s3.listObjects(bucket);
processListing(currentList, succ, fail);
while (currentList.isTruncated()) {
currentList = s3.listNextBatchOfObjects(currentList);
processListing(currentList, succ, fail);
}
json.add(NUM_SUCCEEDED, new JsonPrimitive(succ.size()));
json.add(SUCCEEDED, succ);
json.add(NUM_FAILED, new JsonPrimitive(fail.size()));
json.add(FAILED, fail);
DKV.write_barrier();
Response r = Response.done(json);
r.setBuilder(SUCCEEDED + "." + KEY, new KeyCellBuilder());
return r;
}
private int getTotalBuilds(CIJob job) throws PhrescoException {
try {
S_LOGGER.debug("Entering Method CIManagerImpl.getTotalBuilds(CIJob job)");
S_LOGGER.debug("getCIBuilds() JobName = " + job.getName());
JsonArray jsonArray = getBuildsArray(job);
Gson gson = new Gson();
CIBuild ciBuild = null;
if (jsonArray.size() > 0) {
ciBuild = gson.fromJson(jsonArray.get(0), CIBuild.class);
String buildUrl = ciBuild.getUrl();
String jenkinsUrl = job.getJenkinsUrl() + ":" + job.getJenkinsPort();
// display the jenkins running url in ci
buildUrl = buildUrl.replaceAll("localhost:" + job.getJenkinsPort(), jenkinsUrl);
// list
String response = getJsonResponse(buildUrl + API_JSON);
JsonParser parser = new JsonParser();
JsonElement jsonElement = parser.parse(response);
JsonObject jsonObject = jsonElement.getAsJsonObject();
JsonElement resultJson = jsonObject.get(FrameworkConstants.CI_JOB_BUILD_RESULT);
JsonArray asJsonArray =
jsonObject.getAsJsonArray(FrameworkConstants.CI_JOB_BUILD_ARTIFACTS);
// when build result is not known
if (jsonObject.get(FrameworkConstants.CI_JOB_BUILD_RESULT).toString().equals(STRING_NULL)) {
// it indicates the job is in progress and not yet completed
return -1;
// when build is success and build zip relative path is unknown
} else if (resultJson.getAsString().equals(CI_SUCCESS_FLAG) && asJsonArray.size() < 1) {
return -1;
} else {
return jsonArray.size();
}
} else {
return -1; // When the project is build first time,
}
} catch (ClientHandlerException ex) {
S_LOGGER.error(ex.getLocalizedMessage());
throw new PhrescoException(ex);
}
}
public List<RollupTask> parseRollupTasks(String json)
throws BeanValidationException, QueryException {
List<RollupTask> tasks = new ArrayList<RollupTask>();
JsonParser parser = new JsonParser();
JsonArray rollupTasks = parser.parse(json).getAsJsonArray();
for (int i = 0; i < rollupTasks.size(); i++) {
JsonObject taskObject = rollupTasks.get(i).getAsJsonObject();
RollupTask task = parseRollupTask(taskObject, "tasks[" + i + "]");
task.addJson(taskObject.toString().replaceAll("\\n", ""));
tasks.add(task);
}
return tasks;
}
private void setBuildStatus(CIBuild ciBuild, CIJob job) throws PhrescoException {
S_LOGGER.debug("Entering Method CIManagerImpl.setBuildStatus(CIBuild ciBuild)");
S_LOGGER.debug("setBuildStatus() url = " + ciBuild.getUrl());
String buildUrl = ciBuild.getUrl();
String jenkinsUrl = job.getJenkinsUrl() + ":" + job.getJenkinsPort();
buildUrl =
buildUrl.replaceAll(
"localhost:" + job.getJenkinsPort(),
jenkinsUrl); // display the jenkins running url in ci list
String response = getJsonResponse(buildUrl + API_JSON);
JsonParser parser = new JsonParser();
JsonElement jsonElement = parser.parse(response);
JsonObject jsonObject = jsonElement.getAsJsonObject();
JsonElement resultJson = jsonObject.get(FrameworkConstants.CI_JOB_BUILD_RESULT);
JsonElement idJson = jsonObject.get(FrameworkConstants.CI_JOB_BUILD_ID);
JsonElement timeJson = jsonObject.get(FrameworkConstants.CI_JOB_BUILD_TIME_STAMP);
JsonArray asJsonArray = jsonObject.getAsJsonArray(FrameworkConstants.CI_JOB_BUILD_ARTIFACTS);
if (jsonObject
.get(FrameworkConstants.CI_JOB_BUILD_RESULT)
.toString()
.equals(STRING_NULL)) { // when build is result is not known
ciBuild.setStatus(INPROGRESS);
} else if (resultJson.getAsString().equals(CI_SUCCESS_FLAG)
&& asJsonArray.size()
< 1) { // when build is success and zip relative path is not added in json
ciBuild.setStatus(INPROGRESS);
} else {
ciBuild.setStatus(resultJson.getAsString());
// download path
for (JsonElement jsonArtElement : asJsonArray) {
String buildDownloadZip =
jsonArtElement
.getAsJsonObject()
.get(FrameworkConstants.CI_JOB_BUILD_DOWNLOAD_PATH)
.toString();
if (buildDownloadZip.endsWith(CI_ZIP)) {
if (debugEnabled) {
S_LOGGER.debug("download artifact " + buildDownloadZip);
}
ciBuild.setDownload(buildDownloadZip);
}
}
}
ciBuild.setId(idJson.getAsString());
String dispFormat = DD_MM_YYYY_HH_MM_SS;
ciBuild.setTimeStamp(getDate(timeJson.getAsString(), dispFormat));
}
@Override
public FriendList deserialize(JsonElement je, Type typeOfT, JsonDeserializationContext context)
throws JsonParseException {
FriendList friendList = new FriendList();
JsonObject response = (JsonObject) je.getAsJsonObject().get("response");
JsonArray items = response.getAsJsonObject().getAsJsonArray("items");
for (int i = 0; i < items.size(); i++) {
Friend friend = context.deserialize(items.get(i), Friend.class);
friendList.getFriends().add(friend);
}
return friendList;
}
public static Class<? extends NBTBase> getNBTTypeSmart(JsonElement element) {
if (element.isJsonArray()) {
JsonArray array = element.getAsJsonArray();
if (array.size() == 0) {
return NBTTagList.class;
}
boolean allByte = true;
boolean allInt = true;
for (JsonElement arrayElement : array) {
if (arrayElement.isJsonPrimitive()) {
JsonPrimitive primitive = arrayElement.getAsJsonPrimitive();
if (!(primitive.isNumber() && primitive.getAsNumber() instanceof Byte)) {
allByte = false;
}
if (!(primitive.isNumber() && primitive.getAsNumber() instanceof Integer)) {
allInt = false;
}
} else {
allByte = false;
allInt = false;
}
}
if (allByte) {
return NBTTagByteArray.class;
}
if (allInt) {
return NBTTagIntArray.class;
}
return NBTTagList.class;
} else if (element.isJsonObject()) {
return NBTTagCompound.class;
} else if (element.isJsonPrimitive()) {
JsonPrimitive primitive = element.getAsJsonPrimitive();
if (primitive.isString()) {
return NBTTagString.class;
} else if (primitive.isNumber()) {
return NBTBase.NBTPrimitive.class;
}
}
return null;
}
public WxMpUserList deserialize(
JsonElement json, Type typeOfT, JsonDeserializationContext context)
throws JsonParseException {
JsonObject o = json.getAsJsonObject();
WxMpUserList wxMpUserList = new WxMpUserList();
wxMpUserList.setTotal(GsonHelper.getInteger(o, "total"));
wxMpUserList.setCount(GsonHelper.getInteger(o, "count"));
wxMpUserList.setNextOpenId(GsonHelper.getString(o, "next_openid"));
if (!o.get("data").isJsonNull()
&& !o.get("data").getAsJsonObject().get("openid").isJsonNull()) {
JsonArray data = o.get("data").getAsJsonObject().get("openid").getAsJsonArray();
for (int i = 0; i < data.size(); i++) {
wxMpUserList.getOpenIds().add(GsonHelper.getAsString(data.get(i)));
}
}
return wxMpUserList;
}
public WxCpUser deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
throws JsonParseException {
JsonObject o = json.getAsJsonObject();
WxCpUser user = new WxCpUser();
user.setUserId(GsonHelper.getString(o, "userid"));
user.setName(GsonHelper.getString(o, "name"));
if (o.get("department") != null) {
JsonArray departJsonArray = o.get("department").getAsJsonArray();
Integer[] departIds = new Integer[departJsonArray.size()];
int i = 0;
for (JsonElement jsonElement : departJsonArray) {
departIds[i++] = jsonElement.getAsInt();
}
user.setDepartIds(departIds);
}
user.setPosition(GsonHelper.getString(o, "position"));
user.setMobile(GsonHelper.getString(o, "mobile"));
Integer gender = GsonHelper.getInteger(o, "gender");
if (new Integer(1).equals(gender)) {
user.setGender("男");
} else if (new Integer(2).equals(gender)) {
user.setGender("女");
} else {
user.setGender("未知");
}
user.setTel(GsonHelper.getString(o, "tel"));
user.setEmail(GsonHelper.getString(o, "email"));
user.setWeiXinId(GsonHelper.getString(o, "weixinid"));
user.setAvatar(GsonHelper.getString(o, "avatar"));
user.setStatus(GsonHelper.getInteger(o, "status"));
if (GsonHelper.isNotNull(o.get("extattr"))) {
JsonArray attrJsonElements = o.get("extattr").getAsJsonObject().get("attrs").getAsJsonArray();
for (JsonElement attrJsonElement : attrJsonElements) {
WxCpUser.Attr attr =
new WxCpUser.Attr(
GsonHelper.getString(attrJsonElement.getAsJsonObject(), "name"),
GsonHelper.getString(attrJsonElement.getAsJsonObject(), "value"));
user.getExtAttrs().add(attr);
}
}
return user;
}
public RollupTask parseRollupTask(JsonObject rollupTask, String context)
throws BeanValidationException, QueryException {
RollupTask task = m_gson.fromJson(rollupTask.getAsJsonObject(), RollupTask.class);
validateObject(task);
JsonArray rollups = rollupTask.getAsJsonObject().getAsJsonArray("rollups");
if (rollups != null) {
for (int j = 0; j < rollups.size(); j++) {
JsonObject rollupObject = rollups.get(j).getAsJsonObject();
Rollup rollup = m_gson.fromJson(rollupObject, Rollup.class);
context = context + "rollup[" + j + "]";
validateObject(rollup, context);
JsonObject queryObject = rollupObject.getAsJsonObject("query");
List<QueryMetric> queries = parseQueryMetric(queryObject, context);
for (int k = 0; k < queries.size(); k++) {
QueryMetric query = queries.get(k);
context += ".query[" + k + "]";
validateHasRangeAggregator(query, context);
// Add aggregators needed for rollups
SaveAsAggregator saveAsAggregator =
(SaveAsAggregator) m_aggregatorFactory.createAggregator("save_as");
saveAsAggregator.setMetricName(rollup.getSaveAs());
TrimAggregator trimAggregator =
(TrimAggregator) m_aggregatorFactory.createAggregator("trim");
trimAggregator.setTrim(TrimAggregator.Trim.LAST);
query.addAggregator(saveAsAggregator);
query.addAggregator(trimAggregator);
}
rollup.addQueries(queries);
task.addRollup(rollup);
}
}
return task;
}
private void parseAggregators(
String context, QueryMetric queryMetric, JsonArray aggregators, DateTimeZone timeZone)
throws QueryException, BeanValidationException {
for (int J = 0; J < aggregators.size(); J++) {
JsonObject jsAggregator = aggregators.get(J).getAsJsonObject();
JsonElement name = jsAggregator.get("name");
if (name == null || name.getAsString().isEmpty())
throw new BeanValidationException(
new SimpleConstraintViolation("aggregators[" + J + "]", "must have a name"), context);
String aggContext = context + ".aggregators[" + J + "]";
String aggName = name.getAsString();
Aggregator aggregator = m_aggregatorFactory.createAggregator(aggName);
if (aggregator == null)
throw new BeanValidationException(
new SimpleConstraintViolation(aggName, "invalid aggregator name"), aggContext);
// If it is a range aggregator we will default the start time to
// the start of the query.
if (aggregator instanceof RangeAggregator) {
RangeAggregator ra = (RangeAggregator) aggregator;
ra.setStartTime(queryMetric.getStartTime());
}
if (aggregator instanceof TimezoneAware) {
TimezoneAware ta = (TimezoneAware) aggregator;
ta.setTimeZone(timeZone);
}
if (aggregator instanceof GroupByAware) {
GroupByAware groupByAware = (GroupByAware) aggregator;
groupByAware.setGroupBys(queryMetric.getGroupBys());
}
deserializeProperties(aggContext, jsAggregator, aggName, aggregator);
validateObject(aggregator, aggContext);
queryMetric.addAggregator(aggregator);
}
}
/** **************** Creation tests * **************** */
@Test
public void testCreate() {
try {
// Constructors
JsonArray array = new JsonArray();
assertEquals(0, array.size());
JsonArray array2 = new JsonArray(57);
assertEquals(0, array2.size());
// add(Object) + get(int)
Object addObj = new Object();
array.add(addObj);
assertEquals(1, array.size());
assertEquals(addObj, array.get(0));
Object addObj2 = new Object();
array.add(addObj2);
assertEquals(2, array.size());
assertEquals(addObj2, array.get(1));
// add(JsonObject) + getObject(int)
JsonObject addJObj = new JsonObject();
array.add(addJObj);
assertEquals(3, array.size());
assertEquals(addJObj, array.getObject(2));
// add(JsonArray) + getArray(int)
JsonArray addJArray = new JsonArray();
array.add(addJArray);
assertEquals(4, array.size());
assertEquals(addJArray, array.getArray(3));
// add(String) + getString(int)
String addStr = "Kawaii desu!";
array.add(addStr);
assertEquals(5, array.size());
assertEquals(addStr, array.getString(4));
// add(int) + getLong(int)
int addInt = 1_2_4_8;
array.add(addInt);
assertEquals(6, array.size());
assertEquals(addInt, array.getLong(5).longValue());
// add(long) + getLong(int)
long addLong = 1_2_4_8_16_32_64;
array.add(addLong);
assertEquals(7, array.size());
assertEquals(addLong, array.getLong(6).longValue());
// add(float) + getDouble(int)
float addFloat = 1_2_4_8.0f;
array.add(addFloat);
assertEquals(8, array.size());
assertEquals(addFloat, array.getDouble(7).doubleValue(), 0.01);
// add(double) + getDouble(int)
double addDouble = 1_2_4_8.16_32_64;
array.add(addDouble);
assertEquals(9, array.size());
assertEquals(addDouble, array.getDouble(8).doubleValue(), 0.0000001);
// add(boolean) + getBoolean(int)
boolean addBoolean = true;
array.add(addBoolean);
assertEquals(10, array.size());
assertTrue(array.getBoolean(9));
// Clone constructor
JsonArray array3 = new JsonArray(array);
assertEquals(10, array3.size());
assertEquals(addObj, array3.get(0));
assertEquals(addObj2, array3.get(1));
assertEquals(addJObj, array3.getObject(2));
assertEquals(addJArray, array3.getArray(3));
assertEquals(addStr, array3.getString(4));
assertEquals(addInt, array3.getLong(5).longValue());
assertEquals(addLong, array3.getLong(6).longValue());
assertEquals(addFloat, array3.getDouble(7).doubleValue(), 0.01);
assertEquals(addDouble, array3.getDouble(8).doubleValue(), 0.0000001);
assertTrue(array3.getBoolean(9));
} catch (JsonException e) {
fail("This shouldn't happen!");
}
}
public IChatComponent deserialize(
JsonElement p_deserialize_1_,
Type p_deserialize_2_,
JsonDeserializationContext p_deserialize_3_) {
if (p_deserialize_1_.isJsonPrimitive()) {
return new ChatComponentText(p_deserialize_1_.getAsString());
} else if (!p_deserialize_1_.isJsonObject()) {
if (p_deserialize_1_.isJsonArray()) {
JsonArray var11 = p_deserialize_1_.getAsJsonArray();
IChatComponent var12 = null;
Iterator var15 = var11.iterator();
while (var15.hasNext()) {
JsonElement var17 = (JsonElement) var15.next();
IChatComponent var18 = this.deserialize(var17, var17.getClass(), p_deserialize_3_);
if (var12 == null) {
var12 = var18;
} else {
var12.appendSibling(var18);
}
}
return var12;
} else {
throw new JsonParseException(
"Don\'t know how to turn " + p_deserialize_1_.toString() + " into a Component");
}
} else {
JsonObject var4 = p_deserialize_1_.getAsJsonObject();
Object var5;
if (var4.has("text")) {
var5 = new ChatComponentText(var4.get("text").getAsString());
} else if (var4.has("translate")) {
String var6 = var4.get("translate").getAsString();
if (var4.has("with")) {
JsonArray var7 = var4.getAsJsonArray("with");
Object[] var8 = new Object[var7.size()];
for (int var9 = 0; var9 < var8.length; ++var9) {
var8[var9] = this.deserialize(var7.get(var9), p_deserialize_2_, p_deserialize_3_);
if (var8[var9] instanceof ChatComponentText) {
ChatComponentText var10 = (ChatComponentText) var8[var9];
if (var10.getChatStyle().isEmpty() && var10.getSiblings().isEmpty()) {
var8[var9] = var10.getChatComponentText_TextValue();
}
}
}
var5 = new ChatComponentTranslation(var6, var8);
} else {
var5 = new ChatComponentTranslation(var6, new Object[0]);
}
} else if (var4.has("score")) {
JsonObject var13 = var4.getAsJsonObject("score");
if (!var13.has("name") || !var13.has("objective")) {
throw new JsonParseException("A score component needs a least a name and an objective");
}
var5 =
new ChatComponentScore(
JsonUtils.getJsonObjectStringFieldValue(var13, "name"),
JsonUtils.getJsonObjectStringFieldValue(var13, "objective"));
if (var13.has("value")) {
((ChatComponentScore) var5)
.func_179997_b(JsonUtils.getJsonObjectStringFieldValue(var13, "value"));
}
} else {
if (!var4.has("selector")) {
throw new JsonParseException(
"Don\'t know how to turn " + p_deserialize_1_.toString() + " into a Component");
}
var5 =
new ChatComponentSelector(JsonUtils.getJsonObjectStringFieldValue(var4, "selector"));
}
if (var4.has("extra")) {
JsonArray var14 = var4.getAsJsonArray("extra");
if (var14.size() <= 0) {
throw new JsonParseException("Unexpected empty array of components");
}
for (int var16 = 0; var16 < var14.size(); ++var16) {
((IChatComponent) var5)
.appendSibling(
this.deserialize(var14.get(var16), p_deserialize_2_, p_deserialize_3_));
}
}
((IChatComponent) var5)
.setChatStyle(
(ChatStyle) p_deserialize_3_.deserialize(p_deserialize_1_, ChatStyle.class));
return (IChatComponent) var5;
}
}
/** *************** Parsing tests * *************** */
@Test
public void testParse() {
JsonArray obj;
// Empty cases
String[] emptyCases = {
"[]",
"[ ]",
"[ ]",
"[ ]",
"[\t]",
"[\t\t]",
"[\t\t\t]",
"[\n]",
"[\n\n]",
"[\n\n\n]",
"[\n\t\n]"
};
for (int n = 0; n < emptyCases.length; n++) {
assertNotNull(
"Failed to parse empty case " + n + " (" + previousError + "): " + emptyCases[n],
obj = testParseHelper(emptyCases[n]));
assertFalse(obj.isParsingDelayed());
try {
assertEquals("Invalid size,", 0, obj.size());
} catch (JsonException e) {
fail("Failed to get value");
}
}
// String cases
String[] stringCases = {
"[\"value\"]", "[ \"value\" ]", "[\t\"value\"\t]", "[\n\"value\"\n]", "[\n\t\"value\"\n]"
};
for (int n = 0; n < stringCases.length; n++) {
obj = testParseHelper(stringCases[n]);
assertNotNull(
"Failed to parse single case " + n + " (" + previousError + "): " + stringCases[n], obj);
assertFalse(obj.isParsingDelayed());
try {
assertEquals("Invalid size,", 1, obj.size());
String value = obj.getString(0);
assertEquals("value", value);
} catch (JsonException e) {
fail("Failed to get value");
}
}
// Multiple strings
String[] multiStringCases = {
"[\"value\",\"value2\"]",
"[ \"value\", \"value2\" ]",
"[\t\"value\",\t\"value2\"\t]",
"[\n\"value\",\n\"value2\"\n]",
"[\n\t\"value\",\n\t\"value2\"\n]"
};
for (int n = 0; n < multiStringCases.length; n++) {
obj = testParseHelper(multiStringCases[n]);
assertNotNull(
"Failed to parse single case " + n + " (" + previousError + "): " + multiStringCases[n],
obj);
assertFalse(obj.isParsingDelayed());
try {
assertEquals("Invalid size,", 2, obj.size());
String value = obj.getString(0);
assertEquals("value", value);
String value2 = obj.getString(1);
assertEquals("value2", value2);
} catch (JsonException e) {
fail("Failed to get value");
}
}
// Nested objects
String[] objectCases = {
"[{\"key11\":\"value11\",\"key12\":\"value12\"},{\"key21\":\"value21\",\"key22\":\"value22\"}]"
};
for (int n = 0; n < objectCases.length; n++) {
assertNotNull(
"Failed to parse array case " + n + " (" + previousError + "): " + objectCases[n],
obj = testParseHelper(objectCases[n]));
assertFalse(obj.isParsingDelayed());
try {
assertEquals("Invalid size,", 2, obj.size());
JsonObject obj1 = obj.getObject(0);
assertNotNull("Value not found", obj1);
assertFalse(obj1.isParsingDelayed());
assertEquals("Invalid size,", 2, obj1.size());
assertEquals("value11", obj1.get("key11"));
assertEquals("value12", obj1.get("key12"));
JsonObject obj2 = obj.getObject(1);
assertNotNull("Value not found", obj2);
assertFalse(obj2.isParsingDelayed());
assertEquals("Invalid size,", 2, obj2.size());
assertEquals("value21", obj2.get("key21"));
assertEquals("value22", obj2.get("key22"));
} catch (JsonException e) {
fail("Failed to get value: " + e.toString());
}
}
}
private void SetDevCardManager(JsonArray players, JsonObject deck) {
PlayerDevCards newPlayerDevCards = new PlayerDevCards();
PlayerDevCards oldPlayerDevCards = new PlayerDevCards();
PlayerDevCards playedDevCards = new PlayerDevCards();
boolean[] hasPlayedDevCardsList = new boolean[4];
DevCardList devCardStack = new DevCardList();
int monopolyCount = deck.getAsJsonPrimitive("monopoly").getAsInt();
int monumentCount = deck.getAsJsonPrimitive("monument").getAsInt();
int roadBuilderCount = deck.getAsJsonPrimitive("roadBuilding").getAsInt();
int soldierCount = deck.getAsJsonPrimitive("soldier").getAsInt();
int yearOfPlentyCount = deck.getAsJsonPrimitive("yearOfPlenty").getAsInt();
devCardStack.setMonopoly(monopolyCount);
devCardStack.setMonument(monumentCount);
devCardStack.setRoadBuilder(roadBuilderCount);
devCardStack.setSoldier(soldierCount);
devCardStack.setYearOfPlenty(yearOfPlentyCount);
for (int i = 0; i < players.size(); i++) {
if (!players.get(i).isJsonNull()) {
JsonObject player = players.get(i).getAsJsonObject();
int index = player.getAsJsonPrimitive("playerIndex").getAsInt();
JsonObject newDevCards = player.getAsJsonObject("newDevCards");
JsonObject oldDevCards = player.getAsJsonObject("oldDevCards");
// New Dev Cards
{
int monopoly = newDevCards.getAsJsonPrimitive("monopoly").getAsInt();
int monument = newDevCards.getAsJsonPrimitive("monument").getAsInt();
int roadBuilding = newDevCards.getAsJsonPrimitive("roadBuilding").getAsInt();
int soldier = newDevCards.getAsJsonPrimitive("soldier").getAsInt();
int yearOfPlenty = newDevCards.getAsJsonPrimitive("yearOfPlenty").getAsInt();
newPlayerDevCards.setDevCardsForPlayer(
index, new DevCardList(monopoly, monument, roadBuilding, soldier, yearOfPlenty));
}
// Old Dev Cards
{
int monopoly = oldDevCards.getAsJsonPrimitive("monopoly").getAsInt();
int monument = oldDevCards.getAsJsonPrimitive("monument").getAsInt();
int roadBuilding = oldDevCards.getAsJsonPrimitive("roadBuilding").getAsInt();
int soldier = oldDevCards.getAsJsonPrimitive("soldier").getAsInt();
int yearOfPlenty = oldDevCards.getAsJsonPrimitive("yearOfPlenty").getAsInt();
oldPlayerDevCards.setDevCardsForPlayer(
index, new DevCardList(monopoly, monument, roadBuilding, soldier, yearOfPlenty));
}
// Played Dev Cards
{
int monuments = player.getAsJsonPrimitive("monuments").getAsInt();
int soldiers = player.getAsJsonPrimitive("soldiers").getAsInt();
playedDevCards.setDevCardsForPlayer(index, new DevCardList(0, monuments, 0, soldiers, 0));
}
// Has Played Dev Cards List
{
boolean playedDevCard = player.getAsJsonPrimitive("playedDevCard").getAsBoolean();
hasPlayedDevCardsList[index] = playedDevCard;
}
}
}
this.devCardManager =
new DevCardManager(
newPlayerDevCards,
oldPlayerDevCards,
playedDevCards,
hasPlayedDevCardsList,
devCardStack);
}
private void SetMapManager(JsonObject map) {
JsonArray hexes = map.getAsJsonArray("hexes");
JsonArray ports = map.getAsJsonArray("ports");
JsonArray roads = map.getAsJsonArray("roads");
JsonArray settlements = map.getAsJsonArray("settlements");
JsonArray cities = map.getAsJsonArray("cities");
JsonObject robber = map.getAsJsonObject("robber");
int radius = map.getAsJsonPrimitive("radius").getAsInt();
// Return data structures
HashMap<HexLocation, Hex> hexes_r = new HashMap<>();
HashMap<VertexLocation, Settlement> settlements_r = new HashMap<VertexLocation, Settlement>();
HashMap<EdgeLocation, Port> ports_r = new HashMap<EdgeLocation, Port>();
HashMap<EdgeLocation, Road> roads_r = new HashMap<EdgeLocation, Road>();
// Get Hex info
for (int i = 0; i < hexes.size(); i++) {
JsonObject hex = hexes.get(i).getAsJsonObject();
JsonObject location = hex.getAsJsonObject("location");
String resource = "DESERT";
int number = 0;
int x = location.getAsJsonPrimitive("x").getAsInt();
int y = location.getAsJsonPrimitive("y").getAsInt();
// if hex doesn't have resource and number it is desert hex
if (hex.has("resource") && hex.has("number")) {
resource = hex.getAsJsonPrimitive("resource").getAsString();
number = hex.getAsJsonPrimitive("number").getAsInt();
}
// compile into Map structure
Hex entry = new Hex(x, y, resource.toUpperCase(), number);
hexes_r.put(entry.location, entry);
}
// Get Port info
for (int i = 0; i < ports.size(); i++) {
JsonObject port = ports.get(i).getAsJsonObject();
JsonObject location = port.getAsJsonObject("location");
String resource = "THREE";
int x = location.getAsJsonPrimitive("x").getAsInt();
int y = location.getAsJsonPrimitive("y").getAsInt();
// if port doesn't have resource than it is 3:1 and those are for any resource
if (port.has("resource")) resource = port.getAsJsonPrimitive("resource").getAsString();
String direction = port.getAsJsonPrimitive("direction").getAsString();
int ratio = port.getAsJsonPrimitive("ratio").getAsInt();
// compile into Map structure
HexLocation hexLocation = new HexLocation(x, y);
EdgeLocation edgeLocation =
new EdgeLocation(hexLocation, EdgeDirection.valueOf(Direction.shortToLong(direction)));
// edgeLocation = edgeLocation.getNormalizedLocation();
Port entry = new Port(edgeLocation, PortType.valueOf(resource.toUpperCase()), ratio);
ports_r.put(entry.location, entry);
}
// Get road info
for (int i = 0; i < roads.size(); i++) {
JsonObject road = roads.get(i).getAsJsonObject();
JsonObject location = road.getAsJsonObject("location");
int x = location.getAsJsonPrimitive("x").getAsInt();
int y = location.getAsJsonPrimitive("y").getAsInt();
int owner = road.getAsJsonPrimitive("owner").getAsInt();
String direction = location.getAsJsonPrimitive("direction").getAsString();
// compile into Map structure
HexLocation hexLocation = new HexLocation(x, y);
EdgeLocation edgeLocation =
new EdgeLocation(hexLocation, EdgeDirection.valueOf(Direction.shortToLong(direction)));
edgeLocation = edgeLocation.getNormalizedLocation();
Road entry = new Road(edgeLocation, owner);
roads_r.put(entry.location, entry);
}
// Get settlement info
for (int i = 0; i < settlements.size(); i++) {
JsonObject settlement = settlements.get(i).getAsJsonObject();
JsonObject location = settlement.getAsJsonObject("location");
int x = location.getAsJsonPrimitive("x").getAsInt();
int y = location.getAsJsonPrimitive("y").getAsInt();
int owner = settlement.getAsJsonPrimitive("owner").getAsInt();
String direction = location.getAsJsonPrimitive("direction").getAsString();
// compile into Map structure
HexLocation hexLocation = new HexLocation(x, y);
VertexLocation vertexLocation =
new VertexLocation(
hexLocation, VertexDirection.valueOf(Direction.shortToLong(direction)));
vertexLocation = vertexLocation.getNormalizedLocation();
Settlement entry = new Settlement(vertexLocation, owner);
settlements_r.put(entry.location, entry);
}
// Get city info
for (int i = 0; i < cities.size(); i++) {
JsonObject city = cities.get(i).getAsJsonObject();
JsonObject location = city.getAsJsonObject("location");
int x = location.getAsJsonPrimitive("x").getAsInt();
int y = location.getAsJsonPrimitive("y").getAsInt();
int owner = city.getAsJsonPrimitive("owner").getAsInt();
String direction = location.getAsJsonPrimitive("direction").getAsString();
// compile into Map structure
HexLocation hexLocation = new HexLocation(x, y);
VertexLocation vertexLocation =
new VertexLocation(
hexLocation, VertexDirection.valueOf(Direction.shortToLong(direction)));
vertexLocation = vertexLocation.getNormalizedLocation();
Settlement entry = new Settlement(vertexLocation, owner);
entry.makeCity();
settlements_r.put(entry.location, entry);
}
int x = robber.getAsJsonPrimitive("x").getAsInt();
int y = robber.getAsJsonPrimitive("y").getAsInt();
this.mapManager =
new MapManager(hexes_r, settlements_r, ports_r, roads_r, new HexLocation(x, y), radius);
}
private void SetResourceManager(JsonObject bank, JsonArray players, JsonObject tradeOffer) {
ResourceList bankResources;
ResourceList[] playerResources = new ResourceList[4];
boolean[] hasPlayerDiscarded = new boolean[4];
TradeOffer tradeResourcesOffer = null;
// Get bank resources
{
int brick = bank.getAsJsonPrimitive("brick").getAsInt();
int ore = bank.getAsJsonPrimitive("ore").getAsInt();
int sheep = bank.getAsJsonPrimitive("sheep").getAsInt();
int wheat = bank.getAsJsonPrimitive("wheat").getAsInt();
int wood = bank.getAsJsonPrimitive("wood").getAsInt();
bankResources = new ResourceList(brick, ore, sheep, wheat, wood);
}
// Get player resources
for (int i = 0; i < players.size(); i++) {
if (!players.get(i).isJsonNull()) {
JsonObject player = players.get(i).getAsJsonObject();
JsonObject resource = player.getAsJsonObject("resources");
int index = player.getAsJsonPrimitive("playerIndex").getAsInt();
boolean discarded = player.getAsJsonPrimitive("discarded").getAsBoolean();
hasPlayerDiscarded[i] = discarded;
ResourceList resources;
int brick = resource.getAsJsonPrimitive("brick").getAsInt();
int ore = resource.getAsJsonPrimitive("ore").getAsInt();
int sheep = resource.getAsJsonPrimitive("sheep").getAsInt();
int wheat = resource.getAsJsonPrimitive("wheat").getAsInt();
int wood = resource.getAsJsonPrimitive("wood").getAsInt();
resources = new ResourceList(brick, ore, sheep, wheat, wood);
playerResources[index] = resources;
}
}
if (tradeOffer != null) // This is null if there is no current trade offers
{
int sender = tradeOffer.getAsJsonPrimitive("sender").getAsInt();
int receiver = tradeOffer.getAsJsonPrimitive("receiver").getAsInt();
ResourceList resourcesOffer;
JsonObject offer = tradeOffer.getAsJsonObject("offer");
{
int brick = offer.getAsJsonPrimitive("brick").getAsInt();
int ore = offer.getAsJsonPrimitive("ore").getAsInt();
int sheep = offer.getAsJsonPrimitive("sheep").getAsInt();
int wheat = offer.getAsJsonPrimitive("wheat").getAsInt();
int wood = offer.getAsJsonPrimitive("wood").getAsInt();
resourcesOffer = new ResourceList(brick, ore, sheep, wheat, wood);
}
tradeResourcesOffer = new TradeOffer(resourcesOffer, sender, receiver);
}
this.resourceManager =
new ResourceManager(
playerResources, bankResources, tradeResourcesOffer, hasPlayerDiscarded);
}
// 对接收的（click,mouseover,scroll）数据进行处理，并存入events
@Path("/events/store")
@POST
@Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.TEXT_PLAIN)
public void StoreEvents(String data, @Context HttpServletRequest request)
throws UnsupportedEncodingException, IOException {
String schema =
"browser,os,url,ip,loadtime,time,element,id,text,semantics,event,left,top,height,width";
HashSet<String> hs_log = new HashSet<String>();
// System.out.println(data);
// 读取获得的json数据
JsonReader reader = Json.createReader(new StringReader(data));
JsonObject jsonobj = reader.readObject();
reader.close();
// 获取来源IP,读取url，time，events等信息
String ip = "";
String browser = "";
String os = "";
String url = "";
String loadtime = "";
ip = getRemoteHost(request);
browser = jsonobj.getString("browser");
os = jsonobj.getString("os");
url = jsonobj.getString("url").split("\\?")[0];
url = url.replace("http://", "").replace("HTTP://", "").replace("https://", "");
loadtime = jsonobj.getString("loadtime");
JsonArray events = jsonobj.getJsonArray("events");
// 整理数据
for (int i = 0; i < events.size(); i++) {
JsonObject obj = events.getJsonObject(i);
StringBuffer elebuf = new StringBuffer();
// 先存储头信息
elebuf.append(browser);
elebuf.append(",");
elebuf.append(os);
elebuf.append(",");
elebuf.append(url);
elebuf.append(",");
elebuf.append(ip);
elebuf.append(",");
elebuf.append(loadtime);
elebuf.append(",");
// 各个事件的信息
elebuf.append(obj.getString("time"));
elebuf.append(",");
elebuf.append(obj.getString("element"));
elebuf.append(",");
try {
elebuf.append(obj.getString("id"));
} catch (Exception e) {
elebuf.append("");
}
elebuf.append(",");
elebuf.append(obj.getString("text"));
elebuf.append(",");
// 在这里可以引入SVM标注，标注后在存入数据库
// 或者可以读取数据在标注
elebuf.append(""); // semantics,标注后更新
elebuf.append(",");
elebuf.append(obj.getString("event"));
elebuf.append(",");
elebuf.append(obj.getString("left"));
elebuf.append(",");
elebuf.append(obj.getString("top"));
elebuf.append(",");
elebuf.append(obj.getString("height"));
elebuf.append(",");
elebuf.append(obj.getString("width"));
// 添加set中，去重
hs_log.add(elebuf.toString());
}
eventsDAO.insertEvents(schema, hs_log);
// return "Post Data Success!";
}
private List<QueryMetric> parseQueryMetric(JsonObject obj, String contextPrefix)
throws QueryException, BeanValidationException {
List<QueryMetric> ret = new ArrayList<QueryMetric>();
Query query;
try {
query = m_gson.fromJson(obj, Query.class);
validateObject(query);
} catch (ContextualJsonSyntaxException e) {
throw new BeanValidationException(
new SimpleConstraintViolation(e.getContext(), e.getMessage()), "query");
}
JsonArray metricsArray = obj.getAsJsonArray("metrics");
if (metricsArray == null) {
throw new BeanValidationException(
new SimpleConstraintViolation("metric[]", "must have a size of at least 1"),
contextPrefix + "query");
}
for (int I = 0; I < metricsArray.size(); I++) {
String context =
(!contextPrefix.isEmpty() ? contextPrefix + "." : contextPrefix)
+ "query.metric["
+ I
+ "]";
try {
Metric metric = m_gson.fromJson(metricsArray.get(I), Metric.class);
validateObject(metric, context);
long startTime = getStartTime(query, context);
QueryMetric queryMetric =
new QueryMetric(startTime, query.getCacheTime(), metric.getName());
queryMetric.setExcludeTags(metric.isExcludeTags());
queryMetric.setLimit(metric.getLimit());
long endTime = getEndTime(query);
if (endTime > -1) queryMetric.setEndTime(endTime);
if (queryMetric.getEndTime() < startTime)
throw new BeanValidationException(
new SimpleConstraintViolation("end_time", "must be greater than the start time"),
context);
queryMetric.setCacheString(query.getCacheString() + metric.getCacheString());
JsonObject jsMetric = metricsArray.get(I).getAsJsonObject();
JsonElement group_by = jsMetric.get("group_by");
if (group_by != null) {
JsonArray groupBys = group_by.getAsJsonArray();
parseGroupBy(context, queryMetric, groupBys);
}
JsonElement aggregators = jsMetric.get("aggregators");
if (aggregators != null) {
JsonArray asJsonArray = aggregators.getAsJsonArray();
if (asJsonArray.size() > 0)
parseAggregators(context, queryMetric, asJsonArray, query.getTimeZone());
}
JsonElement plugins = jsMetric.get("plugins");
if (plugins != null) {
JsonArray pluginArray = plugins.getAsJsonArray();
if (pluginArray.size() > 0) parsePlugins(context, queryMetric, pluginArray);
}
JsonElement order = jsMetric.get("order");
if (order != null) queryMetric.setOrder(Order.fromString(order.getAsString(), context));
queryMetric.setTags(metric.getTags());
ret.add(queryMetric);
} catch (ContextualJsonSyntaxException e) {
throw new BeanValidationException(
new SimpleConstraintViolation(e.getContext(), e.getMessage()), context);
}
}
return (ret);
}
@Override
@SuppressWarnings("empty-statement")
protected Clan doInBackground() throws Exception {
if (bestMatch == null) { // use fallBack
// URL URL = new
// URL("http://worldoftanks."+gui.getServerRegion()+"/uc/clans/?type=table&offset=0&limit=10&order_by="+this.searchType+"&search="+this.clanTagName+"&echo=2&id=clans_index");
// TODO: does API support orderBy ?!?
URL URL =
new URL(
"http://worldoftanks."
+ gui.getServerRegion()
+ "/uc/clans/api/1.1/?source_token=Intellect_Soft-WoT_Mobile-unofficial_stats&search="
+ this.fallbackInput.replace(" ", "%20")
+ "&offset=0&limit=10");
URLConnection URLConnection = URL.openConnection();
URLConnection.setRequestProperty("Accept", "application/json, text/javascript, */*; q=0.01");
URLConnection.setRequestProperty("Accept-Language", "en-us;q=0.5,en;q=0.3");
URLConnection.setRequestProperty("Accept-Encoding", "paco");
URLConnection.setRequestProperty("Accept-Charset", "ISO-8859-1,utf-8;q=0.7,*;q=0.7");
URLConnection.setRequestProperty("Connection", "close");
URLConnection.setRequestProperty("X-Requested-With", "XMLHttpRequest");
// timeout after 10 seconds
URLConnection.setConnectTimeout(10000);
BufferedReader clanBufferedReader = null;
StringBuilder data = new StringBuilder(3000);
try {
clanBufferedReader =
new BufferedReader(new InputStreamReader(URLConnection.getInputStream(), "UTF8"));
for (String line; (line = clanBufferedReader.readLine()) != null; data.append(line)) ;
} finally {
if (clanBufferedReader != null) clanBufferedReader.close();
}
JsonParser jsonParser = new JsonParser();
JsonObject json = jsonParser.parse(data.toString()).getAsJsonObject();
if (!"ok".equalsIgnoreCase(json.get("status").getAsString())) {
throw new ClanAPIException(json.get("status_code").getAsString(), this.gui);
}
JsonArray results = json.get("data").getAsJsonObject().get("items").getAsJsonArray();
JsonObject json_clan = null;
for (JsonElement e : results) {
JsonObject o = e.getAsJsonObject();
if (fallbackInput.equalsIgnoreCase(o.get(this.searchType).getAsString())) {
json_clan = o;
break;
}
}
if (json_clan == null) {
throw new ClanNotFoundException(this.gui);
}
String name = json_clan.get("name").getAsString();
String tag = json_clan.get("abbreviation").getAsString();
long ID = json_clan.get("id").getAsLong();
int member_count = json_clan.get("member_count").getAsInt();
ImageIcon emblem =
new ImageIcon(
new URL("http://worldoftanks.eu" + json_clan.get("clan_emblem_url").getAsString()));
bestMatch = new PossibleClan(name, tag, ID, member_count, emblem);
}
// get provinces
GetProvinces provinceWorker = new GetProvinces(bestMatch.getID(), this.gui);
provinceWorker.execute();
// get members
// URL = new
// URL("http://worldoftanks."+gui.getServerRegion()+"/uc/clans/"+clanID+"/members/?type=table&offset=0&limit=100&order_by=name&search=&echo=1&id=clan_members_index");
URL URL =
new URL(
"http://worldoftanks."
+ gui.getServerRegion()
+ "/uc/clans/"
+ bestMatch.getID()
+ "/api/1.1/?source_token=Intellect_Soft-WoT_Mobile-unofficial_stats");
URLConnection URLConnection = URL.openConnection();
URLConnection.setRequestProperty("Accept", "application/json, text/javascript, */*; q=0.01");
URLConnection.setRequestProperty("Accept-Language", "en-us;q=0.5,en;q=0.3");
URLConnection.setRequestProperty("Accept-Encoding", "paco");
URLConnection.setRequestProperty("Accept-Charset", "ISO-8859-1,utf-8;q=0.7,*;q=0.7");
URLConnection.setRequestProperty("Connection", "close");
URLConnection.setRequestProperty("X-Requested-With", "XMLHttpRequest");
// timeout after 15 seconds
URLConnection.setConnectTimeout(15000);
BufferedReader membersBufferedReader = null;
StringBuilder members_data = new StringBuilder(10000);
try {
membersBufferedReader =
new BufferedReader(new InputStreamReader(URLConnection.getInputStream(), "UTF8"));
for (String line;
(line = membersBufferedReader.readLine()) != null;
members_data.append(line)) ;
} finally {
if (membersBufferedReader != null) membersBufferedReader.close();
}
JsonParser jsonParser = new JsonParser();
JsonObject members_json = jsonParser.parse(members_data.toString()).getAsJsonObject();
if (!"ok".equalsIgnoreCase(members_json.get("status").getAsString())) {
throw new ClanAPIException(members_json.get("status_code").getAsString(), this.gui);
}
JsonArray members = members_json.get("data").getAsJsonObject().get("members").getAsJsonArray();
GetPlayerData[] workers = new GetPlayerData[members.size()];
players = new ArrayList<Player>(members.size());
for (int i = 0; i < members.size(); i++) {
JsonObject member = members.get(i).getAsJsonObject();
workers[i] = new GetPlayerData(member.get("account_id").getAsLong(), this.gui);
workers[i].execute();
} // TODO: see if there's some sort of "worker pool" with a getAll() or getFirst()
// In the meantime see if GetProvinces is ready
this.provinces = provinceWorker.get();
ArrayList<Vehicle> vehicles = new ArrayList<Vehicle>(5000);
long start = System.currentTimeMillis();
for (GetPlayerData w : workers) {
Player p = w.get();
players.add(p);
vehicles.addAll(p.getVehicles());
// TODO: update progress bar
// TODO: sort by tier already here ?!? (implementation details)
}
vehicles.trimToSize();
System.out.printf(
"Vs:" + vehicles.size() + "\nOverall time: %dms%n", System.currentTimeMillis() - start);
vehicles = Utils.sortVehiclesByTier(vehicles);
vehicles = Utils.sortVehiclesByClass(vehicles);
vehicles = Utils.sortVehiclesByNation(vehicles);
if (players.size() > 20) { // some small logical optimizations
double avg_top_eff = 0D, avg_eff = 0D, avg_top_wr = 0D, avg_wr = 0D;
players = Utils.sortPlayersByEfficiency(players);
for (int i = 0; i < players.size(); i++) {
if (i == 20) avg_top_eff = avg_eff / 20D;
avg_eff += players.get(i).getEfficiency();
}
avg_eff /= players.size();
players = Utils.sortPlayersByWinrate(players);
for (int i = 0; i < players.size(); i++) {
if (i == 20) avg_top_wr = avg_wr / 20D;
avg_wr += players.get(i).getAvg_wr();
}
avg_wr /= players.size();
return new Clan(
bestMatch.getName(),
bestMatch.getClanTag(),
bestMatch.getID(),
players,
vehicles,
avg_wr,
avg_top_wr,
avg_eff,
avg_top_eff,
bestMatch.getEmblem());
} else {
double avg_eff = 0D, avg_wr = 0D; // top=all
players = Utils.sortPlayersByEfficiency(players);
for (int i = 0; i < players.size(); i++) {
avg_eff += players.get(i).getEfficiency();
}
avg_eff /= players.size();
players = Utils.sortPlayersByWinrate(players);
for (int i = 0; i < players.size(); i++) {
avg_wr += players.get(i).getAvg_wr();
}
avg_wr /= players.size();
return new Clan(
bestMatch.getName(),
bestMatch.getClanTag(),
bestMatch.getID(),
players,
vehicles,
avg_wr,
avg_wr,
avg_eff,
avg_eff,
bestMatch.getEmblem());
}
}
/** ************* Value tests * ************* */
@Test
public void testValues() {
// Longs
String[] objectsJson = {"[{}]", "[{}, {}]", "[{}, {}, {}]"};
JsonObject[][] objectsEx = {
{new JsonObject()},
{new JsonObject(), new JsonObject()},
{new JsonObject(), new JsonObject(), new JsonObject()}
};
for (int objectsJsoff = 0; objectsJsoff < objectsJson.length; objectsJsoff++) {
String json = objectsJson[objectsJsoff];
JsonObject[] ex = objectsEx[objectsJsoff];
JsonArray parsed = new TestArray(json, false);
assertEquals(ex.length, parsed.size());
for (int e = 0; e < ex.length; e++) {
// Valid
assertEquals(ex[e], ((JsonObject) parsed.get(e)));
assertEquals(ex[e], parsed.getObject(e));
// Invalid
invalidValueHelper(parsed, "getArray", e);
invalidValueHelper(parsed, "getString", e);
invalidValueHelper(parsed, "getLong", e);
invalidValueHelper(parsed, "getInt", e);
invalidValueHelper(parsed, "getDouble", e);
invalidValueHelper(parsed, "getFloat", e);
invalidValueHelper(parsed, "getBoolean", e);
}
}
// Strings
String[] stringsJson = {
"[\"test1\"]", "[\"test1\", \"test2\"]", "[\"test1\", \"test2\", \"test3\"]"
};
String[][] stringsEx = {{"test1"}, {"test1", "test2"}, {"test1", "test2", "test3"}};
for (int stringsJsoff = 0; stringsJsoff < stringsJson.length; stringsJsoff++) {
String json = stringsJson[stringsJsoff];
String[] ex = stringsEx[stringsJsoff];
JsonArray parsed = new TestArray(json, false);
assertEquals(ex.length, parsed.size());
for (int e = 0; e < ex.length; e++) {
// Valid
assertEquals(ex[e], (String) parsed.get(e));
assertEquals(ex[e], parsed.getString(e));
// Invalid
invalidValueHelper(parsed, "getObject", e);
invalidValueHelper(parsed, "getArray", e);
invalidValueHelper(parsed, "getLong", e);
invalidValueHelper(parsed, "getInt", e);
invalidValueHelper(parsed, "getDouble", e);
invalidValueHelper(parsed, "getFloat", e);
invalidValueHelper(parsed, "getBoolean", e);
}
}
// Longs
String[] longsJson = {"[1]", "[1, 2]", "[1, 2, 3]"};
long[][] longsEx = {{1}, {1, 2}, {1, 2, 3}};
for (int intsJsoff = 0; intsJsoff < longsJson.length; intsJsoff++) {
String json = longsJson[intsJsoff];
long[] ex = longsEx[intsJsoff];
JsonArray parsed = new TestArray(json, false);
assertEquals(ex.length, parsed.size());
for (int e = 0; e < ex.length; e++) {
// Valid
assertEquals(ex[e], ((Long) parsed.get(e)).longValue());
assertEquals(ex[e], parsed.getLong(e).longValue());
assertEquals(ex[e], parsed.getInt(e).intValue());
// Invalid
invalidValueHelper(parsed, "getObject", e);
invalidValueHelper(parsed, "getArray", e);
invalidValueHelper(parsed, "getString", e);
invalidValueHelper(parsed, "getDouble", e);
invalidValueHelper(parsed, "getFloat", e);
invalidValueHelper(parsed, "getBoolean", e);
}
}
// Floats
String[] floatsJson = {"[1.1]", "[1.1, 2.2f]", "[1.1, 2.2f, 3.3d]"};
float[][] floatsEx = {{1.1f}, {1.1f, 2.2f}, {1.1f, 2.2f, 3.3f}};
for (int floatsJsoff = 0; floatsJsoff < floatsJson.length; floatsJsoff++) {
String json = floatsJson[floatsJsoff];
float[] ex = floatsEx[floatsJsoff];
JsonArray parsed = new TestArray(json, false);
assertEquals(ex.length, parsed.size());
for (int e = 0; e < ex.length; e++) {
// Valid
assertEquals(ex[e], ((Double) parsed.get(e)).doubleValue(), 0.01);
assertEquals(ex[e], parsed.getDouble(e).doubleValue(), 0.01);
assertEquals(ex[e], parsed.getFloat(e).floatValue(), 0.01f);
// Invalid
invalidValueHelper(parsed, "getObject", e);
invalidValueHelper(parsed, "getArray", e);
invalidValueHelper(parsed, "getString", e);
invalidValueHelper(parsed, "getLong", e);
invalidValueHelper(parsed, "getInt", e);
invalidValueHelper(parsed, "getBoolean", e);
}
}
// Booleans
String[] boolJson = {"[true]", "[true, false]", "[true, false, true]"};
boolean[][] boolEx = {{true}, {true, false}, {true, false, true}};
for (int boolsJsoff = 0; boolsJsoff < boolJson.length; boolsJsoff++) {
String json = boolJson[boolsJsoff];
boolean[] ex = boolEx[boolsJsoff];
JsonArray parsed = new TestArray(json, false);
assertEquals(ex.length, parsed.size());
for (int e = 0; e < ex.length; e++) {
// Valid
assertEquals(ex[e], ((Boolean) parsed.get(e)).booleanValue());
assertEquals(ex[e], parsed.getBoolean(e).booleanValue());
// Invalid
invalidValueHelper(parsed, "getObject", e);
invalidValueHelper(parsed, "getArray", e);
invalidValueHelper(parsed, "getString", e);
invalidValueHelper(parsed, "getLong", e);
invalidValueHelper(parsed, "getInt", e);
invalidValueHelper(parsed, "getDouble", e);
invalidValueHelper(parsed, "getFloat", e);
}
}
// Nulls
String[] nullJson = {"[null]", "[null, null]", "[null, null, null]"};
Object[][] nullEx = {
{null}, {null, null}, {null, null, null}
}; // Should I really be expecting anything else?
for (int nullJsoff = 0; nullJsoff < nullJson.length; nullJsoff++) {
String json = nullJson[nullJsoff];
Object[] ex = nullEx[nullJsoff];
JsonArray parsed = new TestArray(json, false);
assertEquals(ex.length, parsed.size());
for (int e = 0; e < ex.length; e++) {
// Valid
assertNull(parsed.get(e));
assertNull(parsed.getObject(e));
assertNull(parsed.getArray(e));
assertNull(parsed.getString(e));
assertNull(parsed.getLong(e));
assertNull(parsed.getInt(e));
assertNull(parsed.getDouble(e));
assertNull(parsed.getFloat(e));
assertNull(parsed.getBoolean(e));
}
}
}
