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);
}
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 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;
}
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());
}
}
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);
}
}
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);
}
}
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 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 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;
}
@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 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;
}
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;
}
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);
}
}
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;
}
@When("^I fill the form with data from json and submit$")
public void i_fill_the_form_with_data_from_json_and_submit() throws Throwable {
JsonParser parser = new JsonParser();
JsonObject myobject = (JsonObject) parser.parse(json);
JsonArray myarray = myobject.get("table").getAsJsonArray();
JsonObject pradeep = myarray.get(0).getAsJsonObject();
driver.findElement(By.name("firstname")).sendKeys(pradeep.get("firstname").getAsString());
driver.findElement(By.name("lastname")).sendKeys(pradeep.get("lastname").getAsString());
driver.findElement(By.id("sex-1")).click();
driver.findElement(By.id("exp-2")).click();
driver.findElement(By.id("datepicker")).sendKeys(pradeep.get("date_stopped").getAsString());
driver.findElement(By.id("tea3")).click();
driver.findElement(By.id("tool-1")).click();
Select continents_select = new Select(driver.findElement(By.id("continents")));
continents_select.selectByVisibleText(pradeep.get("continent").getAsString());
Select another_select_list = new Select(driver.findElement(By.id("selenium_commands")));
another_select_list.selectByVisibleText(pradeep.get("selenium_commands").getAsString());
driver.findElement(By.id("submit")).click();
AssertJUnit.assertEquals("Welcome", driver.getTitle());
}
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);
}
}
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 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);
}
@Test
public void testCreateFailures() {
// Delayed invalid JSON
JsonArray array = null;
try {
array = JsonParser.parseArray("[{]", true);
} catch (JsonParseException e) {
fail("This shouldn't happen!");
}
// get(int)
try {
array.get(0);
fail("Didn't throw an exception on delayed invalid JSON");
} catch (JsonParseException e) {
} catch (Exception e) {
e.printStackTrace();
fail("Wrong exception!");
}
// getObject(int)
try {
array.getObject(0);
fail("Didn't throw an exception on delayed invalid JSON");
} catch (JsonParseException e) {
} catch (Exception e) {
fail("Wrong exception!");
}
// getArray(int)
try {
array.getArray(0);
fail("Didn't throw an exception on delayed invalid JSON");
} catch (JsonParseException e) {
} catch (Exception e) {
fail("Wrong exception!");
}
// getString(int)
try {
array.getString(0);
fail("Didn't throw an exception on delayed invalid JSON");
} catch (JsonParseException e) {
} catch (Exception e) {
fail("Wrong exception!");
}
// getLong(int)
try {
array.getLong(0);
fail("Didn't throw an exception on delayed invalid JSON");
} catch (JsonParseException e) {
} catch (Exception e) {
fail("Wrong exception!");
}
// getDouble(int)
try {
array.getDouble(0);
fail("Didn't throw an exception on delayed invalid JSON");
} catch (JsonParseException e) {
} catch (Exception e) {
fail("Wrong exception!");
}
// getBoolean(int)
try {
array.getBoolean(0);
fail("Didn't throw an exception on delayed invalid JSON");
} catch (JsonParseException e) {
} catch (Exception e) {
fail("Wrong exception!");
}
}
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);
}
/** **************** 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!");
}
}
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);
}
public void logController(String topic, MqttMessage mqttMessage) {
// get deviceId
String[] split = topic.split("log/");
String deviceId = split[1];
// parse log
try {
JsonReader reader = Json.createReader(new StringReader(mqttMessage.toString()));
JsonObject jsonMessage = reader.readObject();
String logType = jsonMessage.getString("type");
switch (logType) {
case LOG_NORMAL:
int temperature = 0;
int timer = jsonMessage.getInt("time");
try {
temperature = jsonMessage.getInt("temperature");
} catch (Exception se1) {
// @todo: warning
break;
}
JsonString subDeviceId = jsonMessage.getJsonString("subId");
if (subDeviceId == null) sessionHandle.drawTemperature(deviceId, timer, temperature);
else sessionHandle.drawTemperature(deviceId, timer, temperature, subDeviceId.toString());
break;
case LOG_WARNING:
timer = jsonMessage.getInt("time");
subDeviceId = jsonMessage.getJsonString("subId");
int subdeviceNo = jsonMessage.getInt("number");
String deviceState = jsonMessage.getString("value");
String msg;
switch (subdeviceNo) {
case 1:
msg = ("0".equals(deviceState)) ? "Button release" : "Button clicked";
break;
case 2:
msg = ("0".equals(deviceState)) ? "Cửa cuốn được cuộn lên" : "Đang thả cửa cuốn";
break;
default:
msg = DEFAULT_ALERT_MSG;
break;
}
if (subDeviceId == null) sessionHandle.doAlert(deviceId, timer, msg);
else sessionHandle.doAlert(deviceId, timer, msg, subDeviceId.toString());
break;
case LOG_CONTROL:
String state = jsonMessage.getString("light");
subdeviceNo = jsonMessage.getInt("no");
sessionHandle.updateLightState(deviceId, subdeviceNo, state);
break;
case LOG_ACK:
subdeviceNo = jsonMessage.getInt("number");
deviceState = jsonMessage.getString("value");
state = ("0".equals(deviceState)) ? "off" : "on";
sessionHandle.ackLightState(deviceId, subdeviceNo, state);
break;
case LOG_DEVICE_STATUS:
JsonArray lstDevice = jsonMessage.getJsonArray("status");
System.out.println("Update status:");
for (int i = 0; i < lstDevice.size(); i++) {
JsonObject device = (JsonObject) lstDevice.get(i);
System.out.println(device.toString());
subdeviceNo = device.getInt("no");
int intState = device.getInt("value");
state = (intState == 0) ? "off" : "on";
sessionHandle.updateLightState(deviceId, subdeviceNo, state);
}
sessionHandle.finishUpdateDeviceStatus();
break;
default:
}
} catch (Exception ex) {
System.out.println("Parse error");
System.out.println(topic);
System.out.println(mqttMessage);
System.out.println(ex.getMessage());
}
}
/** ************* 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));
}
}
}
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;
}
}
@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());
}
}
@Test
public void TestGetReservationForFlights() {
// given().
// // use auth token for oauth v2 header
// auth().oauth2(token).
// // make call to API
// when().get("https://" + apiServiceBaseURL + "/api/api/flight")
// .then()
// .body("size()", greaterThanOrEqualTo(0));
// TODO - fraglich ob das so läuft
String urlId = "http://localhost:8080/api/flights";
String jsonId = given().get(urlId).getBody().print();
JsonParser parser = new JsonParser();
JsonArray arr = parser.parse(jsonId).getAsJsonArray();
JsonElement jsonElement = arr.get(0);
JsonObject jsonObject = jsonElement.getAsJsonObject();
UUID testId = UUID.fromString(jsonObject.get("flightId").getAsString());
// TODO - Für welche FlightId sollen die Reservierungen angefragt werden??
UUID id = UUID.fromString("76fc2e8d-7587-4a18-b2f8-33eeda154b8b");
String url = "http://localhost:8080/api/tickets/flight/";
// TODO - hier muss die Id ggf. gewechselt werden
String json = given().get(url + testId).getBody().print();
// Prüft die Länge des Arrays mit Flügen >= 1
given().get(url).then().body("size()", greaterThan(0));
// Prüfen ob TicketId !=null ist
given().get(url).then().body("get(0).ticketId", notNullValue());
// Prüfen ob TicketId ist instanceOf Integer
given().get(url).then().body("get(0).ticketId", instanceOf(Integer.class));
// Prüfen ob passengerArray !=null ist
given().get(url).then().body("get(0).passenger", notNullValue());
// Prüfen ob reservationArray !=null ist
given().get(url).then().body("get(0).reservation", notNullValue());
// Prüfen ob in Reservation eine Buchungsart vorhanden ist
given().get(url).then().body("get(0).reservation.reservationType", notNullValue());
// Prüft ob ReservationType vom Typ "Eco", "Busi" oder "First" ist
// given().get(url).then().body("get(0).reservation.reservationType", contains("Economy")
// || contains("Business"));
// Prüfen ob in Reservation die ReservationId ist instanceOf Integer
given().get(url).then().body("get(0).reservation.reservationId", instanceOf(Integer.class));
// Prüfen ob Bookingtype !=null ist
given().get(url).then().body("get(0).bookingType", notNullValue());
// Prüfen ob TicketDate !=null ist
given().get(url).then().body("get(0).ticketDate.length()", greaterThan(0));
// Prüfen ob in Reservation CheckedIn ist instanceOf Boolean
// given().get(url).then().body("get(0).reservation.checkedIn",
// instanceOf(Boolean.class));
}
@Override
public String build(Response response, JsonObject cm, String contextName) {
StringBuilder sb = new StringBuilder();
if (cm.has(JSON_CM_MATRIX)) {
sb.append("<h3>Confusion matrix - ")
.append(cm.get(JSON_CM_TYPE).getAsString())
.append("</h3>");
sb.append("<dl class='dl-horizontal'>");
sb.append("<dt>classification error</dt><dd>")
.append(String.format("%5.3f %%", 100 * cm.get(JSON_CM_CLASS_ERR).getAsFloat()))
.append("</dd>");
long rows = cm.get(JSON_CM_ROWS).getAsLong();
long skippedRows = cm.get(JSON_CM_ROWS_SKIPPED).getAsLong();
sb.append("<dt>used / skipped rows </dt><dd>")
.append(
String.format(
"%d / %d (%3.1f %%)",
rows, skippedRows, (double) skippedRows * 100 / (skippedRows + rows)))
.append("</dd>");
sb.append("<dt>trees used</dt><dd>" + cm.get(JSON_CM_TREES).getAsInt()).append("</dd>");
sb.append("</dl>");
sb.append("<table class='table table-striped table-bordered table-condensed'>");
sb.append("<tr><th>Actual \\ Predicted</th>");
JsonArray header = (JsonArray) cm.get(JSON_CM_HEADER);
for (JsonElement e : header) sb.append("<th>" + e.getAsString() + "</th>");
sb.append("<th>Error</th></tr>");
int classes = header.size();
long[] totals = new long[classes];
JsonArray matrix = (JsonArray) cm.get(JSON_CM_MATRIX);
long sumTotal = 0;
long sumError = 0;
for (int crow = 0; crow < classes; ++crow) {
JsonArray row = (JsonArray) matrix.get(crow);
long total = 0;
long error = 0;
sb.append("<tr><th>" + header.get(crow).getAsString() + "</th>");
for (int ccol = 0; ccol < classes; ++ccol) {
long num = row.get(ccol).getAsLong();
total += num;
totals[ccol] += num;
if (ccol == crow) {
sb.append("<td style='background-color:LightGreen'>");
} else {
sb.append("<td>");
error += num;
}
sb.append(num);
sb.append("</td>");
}
sb.append("<td>");
sb.append(String.format("%5.3f = %d / %d", (double) error / total, error, total));
sb.append("</td></tr>");
sumTotal += total;
sumError += error;
}
sb.append("<tr><th>Totals</th>");
for (int i = 0; i < totals.length; ++i) sb.append("<td>" + totals[i] + "</td>");
sb.append("<td><b>");
sb.append(
String.format("%5.3f = %d / %d", (double) sumError / sumTotal, sumError, sumTotal));
sb.append("</b></td></tr>");
sb.append("</table>");
} else {
sb.append("<div class='alert alert-info'>");
sb.append("Confusion matrix is being computed into the key:</br>");
sb.append(cm.get(JSON_CONFUSION_KEY).getAsString());
sb.append("</div>");
}
return sb.toString();
}
