private Point createFeedPoint(final User user) throws NimbitsException {
final EntityName name =
CommonFactoryLocator.getInstance().createName(Const.TEXT_DATA_FEED, EntityType.point);
final Entity entity =
EntityModelFactory.createEntity(
name,
"",
EntityType.feed,
ProtectionLevel.onlyConnection,
user.getKey(),
user.getKey(),
UUID.randomUUID().toString());
// final Entity r = EntityServiceFactory.getInstance().addUpdateEntity(user, entity);
Point point = PointModelFactory.createPointModel(entity);
final Point result = (Point) EntityServiceFactory.getInstance().addUpdateEntity(point);
postToFeed(
user,
"A new data point has been created for your data feed. Your data feed is just "
+ "a data point. Points are capable of storing numbers, text, json and xml data. Nimbits uses "
+ "a single data point to drive this feed.",
FeedType.info);
return result;
}
public Resident getOwner(Object object) {
try {
EntityPlayer player =
getters.contains("owner")
? (EntityPlayer) getters.get("owner").invoke(EntityPlayer.class, object, object)
: null;
if (player == null) return null;
return MyTownUniverse.instance.getOrMakeResident(player);
} catch (GetterException ex) {
try {
String username =
getters.contains("owner")
? (String) getters.get("owner").invoke(String.class, object, object)
: null;
if (username == null) return null;
if (username.length() == 36 && (username.split("-", -1).length - 1) == 4) {
UUID uuid = UUID.fromString(username);
return MyTownUniverse.instance.getOrMakeResident(uuid);
}
return MyTownUniverse.instance.getOrMakeResident(username);
} catch (GetterException ex2) {
try {
UUID uuid =
getters.contains("owner")
? (UUID) getters.get("owner").invoke(UUID.class, object, object)
: null;
if (uuid == null) return null;
return MyTownUniverse.instance.getOrMakeResident(uuid);
} catch (GetterException ex3) {
return null;
}
}
}
}
public final class LauncherProfiles {
public static LauncherProfiles INSTANCE;
static void modified() {
try (FileWriter writer = new FileWriter(getFile())) {
JsonObject obj = deepCopy(INSTANCE.everythingElse);
obj.addProperty("clientToken", INSTANCE.clientToken);
obj.add("authenticationDatabase", GSON.toJsonTree(INSTANCE.authenticationDatabase.profiles));
GSON.toJson(obj, writer);
System.out.println("Profiles saved");
} catch (IOException e) {
e.printStackTrace();
}
}
@SuppressWarnings("unchecked")
public static <T extends JsonElement> T deepCopy(T from) {
if (from == null) {
throw new IllegalArgumentException("from must not be null");
}
if (from instanceof JsonObject) {
return (T) deepCopyObj((JsonObject) from);
}
if (from instanceof JsonArray) {
return (T) deepCopyArr((JsonArray) from);
}
if (from instanceof JsonNull) {
return (T) JsonNull.INSTANCE;
}
if (from instanceof JsonPrimitive) {
// Nulls and primitives are immutable
return from;
}
throw new AssertionError("Unknown element type " + from.getClass().getName());
}
private static JsonObject deepCopyObj(JsonObject from) {
JsonObject result = new JsonObject();
for (Map.Entry<String, JsonElement> entry : from.entrySet()) {
result.add(entry.getKey(), deepCopy(entry.getValue()));
}
return result;
}
private static JsonArray deepCopyArr(JsonArray from) {
JsonArray result = new JsonArray();
for (JsonElement element : from) {
result.add(deepCopy(element));
}
return result;
}
public static LauncherProfiles load() throws IOException {
System.out.println("Loading Minecraft profiles from " + DevLauncher.workingDirectory);
try (FileReader reader = new FileReader(getFile())) {
LauncherProfiles profiles = new LauncherProfiles();
JsonObject e = new JsonParser().parse(reader).getAsJsonObject();
for (Map.Entry<String, JsonElement> entry : e.entrySet()) {
if (entry.getKey().equals("clientToken")) {
profiles.clientToken = entry.getValue().getAsString();
} else if (entry.getKey().equals("authenticationDatabase")) {
JsonObject o = entry.getValue().getAsJsonObject();
for (Map.Entry<String, JsonElement> entry1 : o.entrySet()) {
profiles.authenticationDatabase.profiles.put(
UUIDTypeAdapter.fromString(entry1.getKey()),
GSON.fromJson(entry1.getValue(), OnlineProfile.class));
}
} else {
profiles.everythingElse.add(entry.getKey(), entry.getValue());
}
}
INSTANCE = profiles;
return INSTANCE;
} finally {
if (INSTANCE == null) {
INSTANCE = new LauncherProfiles();
}
INSTANCE.markLoaded();
}
}
private static File getFile() {
File mcDataDir = DevLauncher.workingDirectory;
if (!mcDataDir.exists()) {
mcDataDir.mkdirs();
}
return new File(mcDataDir, "launcher_profiles.json");
}
private final JsonObject everythingElse = new JsonObject();
private String clientToken = UUID.randomUUID().toString();
private final AuthDatabase authenticationDatabase = new AuthDatabase();
private transient UserFactory USERS;
private void markLoaded() {
USERS = new UserFactory(clientToken);
}
public UserFactory getUserFactory() {
return USERS;
}
public String getClientToken() {
return clientToken;
}
public void addProfile(OnlineProfile profile) {
authenticationDatabase.profiles.put(profile.getUUID(), profile);
modified();
}
public void removeProfile(OnlineProfile profile) {
authenticationDatabase.profiles.remove(profile.getUUID());
modified();
}
public Iterable<OnlineProfile> getProfiles() {
return new Iterable<OnlineProfile>() {
@Override
public Iterator<OnlineProfile> iterator() {
final Iterator<OnlineProfile> real = authenticationDatabase.profiles.values().iterator();
return new Iterator<OnlineProfile>() {
@Override
public void remove() {
real.remove();
modified();
}
@Override
public OnlineProfile next() {
return real.next();
}
@Override
public boolean hasNext() {
return real.hasNext();
}
};
}
};
}
private static final Gson GSON =
new GsonBuilder().registerTypeAdapter(UUID.class, new UUIDTypeAdapter()).create();
private static final class AuthDatabase {
private final Map<UUID, OnlineProfile> profiles = new HashMap<>();
}
}
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// start parse param from request
String usersListFilePath = request.getParameter("usersListFilePath");
LOGGER.info("usersListFilePath=" + usersListFilePath);
List<Long> usersToRank = parseUsersIdsFromFile(usersListFilePath);
Date fromDate = getFromDate(request);
LOGGER.info("fromDate=" + fromDate);
Date toDate = getToDate(request);
LOGGER.info("toDate=" + toDate);
List<String> topicTweets = getTopicTweets(request);
LOGGER.info("In Topic Tweets:");
int count = 0;
for (String tweet : topicTweets) {
int i = count++;
LOGGER.debug(i + ") " + tweet);
}
List<String> outOfTopicTweets = getOutOfTopicTweets(request);
LOGGER.info("Out of Topic Tweets:");
count = 0;
for (String tweet : outOfTopicTweets) {
int i = count++;
LOGGER.debug(i + ") " + tweet);
}
int tweetsPerDocument = getTweetsPerDocument(request);
LOGGER.info("tweetsPerDocument=" + tweetsPerDocument);
int k = getK(request);
LOGGER.info("k=" + k);
// end parse param from request
// build the ranking calculator
final TopicScorer topicScorer = initKnnTopicScorer(topicTweets, outOfTopicTweets, k);
final RankingCalculator rankingCalculator =
new RankingCalculator(this.twitterCache, topicScorer);
// use it
final List<RankedUser> rankedUsers =
rankingCalculator.getRankedUsersWithoutUrlsResolution(usersToRank, fromDate, toDate);
LOGGER.info("found users: " + rankedUsers.size());
final List<InfluenceUser> influenceUsers = new LinkedList<InfluenceUser>();
for (RankedUser currentUser : rankedUsers) {
final String screenName = currentUser.getScreenName();
LOGGER.info("loading user by screen name '" + screenName + "'");
final User fromPersistence = loadUserByScreenName(screenName);
final InfluenceUser influencer = new InfluenceUser(currentUser, fromPersistence);
influenceUsers.add(influencer);
}
// serialize in json
final String influencersAsJson =
this.gson.toJson(influenceUsers, new TypeToken<List<InfluenceUser>>() {}.getType());
// write results to file
final String influencersFilename = "influencers-" + UUID.randomUUID().toString() + ".json";
final String influencersFilePath =
this.pl.getInfluencersResultsDirectory() + influencersFilename;
LOGGER.info("writing rankedUsers '" + influencersAsJson + "' to file " + influencersFilePath);
LOGGER.info("influencers to be serialized in json " + influenceUsers.size());
try {
writeStringToFile(influencersFilePath, influencersAsJson);
} catch (IOException e) {
throw new ServletException(
"cant write to file '"
+ influencersFilePath
+ "' these contents: '"
+ influencersAsJson
+ "'",
e);
}
LOGGER.info("wrote file: '" + influencersFilePath + "' - dispatching to view");
request.setAttribute("influencersFilePath", influencersFilePath);
final RequestDispatcher requestDispatcher =
request.getRequestDispatcher("influencers-result.jsp");
requestDispatcher.forward(request, response);
}