Create a gist now

Instantly share code, notes, and snippets.

What would you like to do?
A java class to hook into the theartex.net API
package mathhulk;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.Reader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLEncoder;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.StringJoiner;
import javax.xml.bind.DatatypeConverter;
import com.eclipsesource.json.Json;
import com.eclipsesource.json.JsonArray;
import com.eclipsesource.json.JsonObject;
import com.eclipsesource.json.JsonValue;
/**
* Java hook for the theartex.net API.
*
* @author AL_1
* @see https://www.theartex.net/documentation/
*
*/
public class MathhulkAPI {
/**
* API key to use the API, this is not implemented in the API, but is placed
* in to future proof the hook
*/
private final String APIKey;
/**
* Root URL to the API (Default: https://www.theartex.net/cloud/api/), this
* was only added to future proof the hook
*/
private final String APIURL;
/**
* Initialize the mathhulk java API
*
* @param APIKey
* Key to use mathhulk Developer API <em>(Not in use at the
* moment)</em> Can be null.
* @param APIURL
* URL to API (Default: https://www.theartex.net/cloud/api/) Can
* be null.
*/
public MathhulkAPI(String APIKey, String APIURL) {
this.APIKey = APIKey;
if (APIURL == null || APIURL.trim() == "" || APIURL.trim() == " ") {
this.APIURL = "https://www.theartex.net/cloud/api/";
} else {
this.APIURL = APIURL;
}
}
/**
* The get announcements section of the API allows you to grab a list of
* announcements.<br>
* If you encounter an error or do not receive the result you are looking
* for, be sure to check the message variable in the responseIf you receive
* a successful response, the response variable should be
* <strong><code>"user found"</code></strong>.
*
* @return Json response from server
*/
public Announcements getAnnouncements() {
JsonObject json = Json.parse(post("announcements", new HashMap<>())).asObject();
Announcements ancs = new Announcements(json);
return ancs;
}
/**
* The get alerts section of the API allows you to view the alerts of a
* user.<br>
* If you encounter an error or do not receive the result you are looking
* for, be sure to check the message variable in the responseIf you receive
* a successful response, the response variable should be
* <strong><code>"alerts listed"</code></strong>.
*
* @param user
* User of which to get the alerts.
* @return Json response from server
*/
public Alerts getAlerts(User user) {
Map<String, String> args = new HashMap<>();
args.put("key", user.key);
JsonObject json = Json.parse(post("alerts", args)).asObject();
Alerts alerts = new Alerts(json, user);
return alerts;
}
/**
* The get alerts section of the API allows you to view the alerts of a
* user.<br>
* If you encounter an error or do not receive the result you are looking
* for, be sure to check the message variable in the responseIf you receive
* a successful response, the response variable should be
* <strong><code>"alert updated"</code></strong>.
*
* @param user
* User of which to mark the alert as read.
* @param alertId
* Id of the alert to mark as read.
* @return Json response from server
*/
public Response markAlertAsRead(int alertId, User user) {
Map<String, String> args = new HashMap<>();
args.put("key", user.key);
args.put("id", String.valueOf(alertId));
JsonObject json = Json.parse(post("alert", args)).asObject();
return new Response(json);
}
/**
* The send alert section of the API allows you to send an alert to a
* user.<br>
* If you encounter an error or do not receive the result you are looking
* for, be sure to check the message variable in the responseIf you receive
* a successful response, the response variable should be
* <strong><code>"user alerted"</code></strong>.
*
* @param user
* User of which to send the alert.
* @param title
* Title or name of application/service
* @param message
* Content or alert
* @return Alert object
*/
public Alert sendAlert(User user, String title, String message) {
Map<String, String> args = new HashMap<>();
args.put("key", user.key);
args.put("title", title);
args.put("message", message);
JsonObject json = Json.parse(post("alert", args)).asObject();
return getAlert(user, Integer.parseInt(json.get("data").asObject().get("id").asString()));
}
/**
* The get alert section of the API allows you to get a single alert from a
* user.<br>
* If you encounter an error or do not receive the result you are looking
* for, be sure to check the message variable in the responseIf you receive
* a successful response, the response variable should be
* <strong><code>"alerts listed"</code></strong>.
*
* @param user
* User of which to get the alert.
* @param id
* Id of the alert.
* @return Alert object, can and will return null if alert is not found.
*/
public Alert getAlert(User user, int id) {
for (Alert a : getAlerts(user).getAlets())
if (a.getId() == id)
return a;
return null;
}
/**
* The session section of the API allows you to update the status of a
* user.<br>
* If you encounter an error or do not receive the result you are looking
* for, be sure to check the message variable in the responseIf you receive
* a successful response, the response variable should be
* <strong><code>"session updated"</code></strong>.
*
* @param user
* User of which to update session.
* @param page
* Location of the user (ie. "applicationName://current
* location")
* @param ip
* IP address of the user
* @return Json response from server.
*/
public Response updateSession(User user, String page, String ip) {
Map<String, String> args = new HashMap<>();
args.put("key", user.key);
args.put("page", page);
args.put("ip", ip);
return new Response(Json.parse(post("session", args)).asObject());
}
/**
* The send alert section of the API allows you to send an alert to a
* user.<br>
* If you encounter an error or do not receive the result you are looking
* for, be sure to check the message variable in the responseIf you receive
* a successful response, the response variable should be
* <strong><code>"user alerted"</code></strong>.
*
* @param user
* Username of user
* @param title
* A non-hashed password
* @return User object
*/
public User authenticateUser(String username, String password) {
String passwordHashed = "";
try {
byte[] passwordBytes = password.getBytes(StandardCharsets.UTF_8);
MessageDigest md;
md = MessageDigest.getInstance("MD5");
passwordHashed = DatatypeConverter.printHexBinary(md.digest(passwordBytes));
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
return null;
}
Map<String, String> args = new HashMap<>();
args.put("username", username);
args.put("password", passwordHashed);
String response = post("login", args);
User user = new User(Json.parse(response).asObject());
return user;
}
/**
* The post section of the API allows you to send a post to any section of
* the API with custom parameters.<br>
*
* @param section
* Section of the API
* @param args
* Parameters to send to API
* @return Raw response from server
*/
private String post(String section, Map<String, String> arguments) {
System.out.println("Posting to: " + section + "...");
try {
arguments.put("sec", section);
arguments.put("APIkey", APIKey);
URL url = new URL(APIURL);
URLConnection con = url.openConnection();
HttpURLConnection http = (HttpURLConnection) con;
http.setRequestMethod("POST");
http.setDoOutput(true);
http.setRequestProperty("User-Agent", "Java Mathhulk API by AL_1 / 0.0.1");
http.setRequestProperty("sec", section);
StringJoiner sj = new StringJoiner("&");
for (Map.Entry<String, String> entry : arguments.entrySet())
sj.add(URLEncoder.encode(entry.getKey(), "UTF-8") + "=" + URLEncoder.encode(entry.getValue(), "UTF-8"));
byte[] out = sj.toString().getBytes(StandardCharsets.UTF_8);
int length = out.length;
http.setFixedLengthStreamingMode(length);
http.setRequestProperty("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
http.connect();
try (OutputStream os = http.getOutputStream()) {
os.write(out);
}
InputStream in = http.getInputStream();
StringBuilder textBuilder = new StringBuilder();
try (Reader reader = new BufferedReader(
new InputStreamReader(in, Charset.forName(StandardCharsets.UTF_8.name())))) {
int c = 0;
while ((c = reader.read()) != -1) {
textBuilder.append((char) c);
}
}
String rtn = textBuilder.toString();
System.out.println("Returned: " + rtn);
return rtn;
} catch (IOException e) {
e.printStackTrace();
return "{\"status\":\"error\",\"code\":\"404\",\"message\":\"Post failed (" + e.getMessage() + ")\"}";
}
}
/**
* A standard response object from the API
*
* @author AL_1
*
*/
static class Response {
private final int code;
private final String status, message;
/**
* Creates a new API response
*
* @param json
* Json response from server
*/
public Response(JsonObject json) {
this.code = Integer.parseInt(json.get("code").asString());
this.status = json.get("status").asString();
this.message = json.get("message").asString();
}
/**
* Status/error code of the response
*
* @return Response code
*/
public int getCode() {
return code;
}
/**
* Gets the status of the response
*
* @return Response status
*/
public String getStatus() {
return status;
}
public String getMessage() {
return message;
}
}
/**
* User profile from API
*
* @author AL_1
*
*/
static class User {
private final int id;
private final String username, role, email, key, val;
private final boolean banned, active;
private final Response response;
/**
* Create a user object.
*
* @param json
* Json response from server
*/
public User(JsonObject json) {
this.response = new Response(json);
if (response.getCode() != 0) {
this.id = -1;
this.username = null;
this.role = null;
this.email = null;
this.banned = false;
this.active = false;
this.key = null;
this.val = null;
return;
}
JsonObject userJson = json.get("data").asObject();
this.id = Integer.parseInt(userJson.get("id").asString());
this.username = userJson.get("username").asString();
this.role = userJson.get("role").asString();
this.email = userJson.get("email").asString();
this.key = userJson.get("key").asString();
this.val = userJson.get("val").asString();
String banned = userJson.get("banned").asString();
String active = userJson.get("active").asString();
if (banned.toUpperCase() == "YES") {
this.banned = true;
} else {
this.banned = false;
}
if (active.toUpperCase() == "YES") {
this.active = true;
} else {
this.active = false;
}
}
public Response getResponse() {
return response;
}
/**
* Unique id of user.
*
* @return Id of user
*/
public int getId() {
return id;
}
/**
* Username associated with user
*
* @return Users username
*/
public String getUsername() {
return username;
}
/**
* Gets the role of the user, the current roles are
* <strong>User</strong> and <strong>Administrator</strong>
*
* @return Role of user
*/
public String getRole() {
return role;
}
/**
* Gets the email associated with the account.
*
* @return Users email
*/
public String getEmail() {
return email;
}
/**
* The unique key for the user to allows sending, editing, and listing
* of alerts for that user. This key could be used in more ways in the
* future.
*
* @return Users private key
*/
public String getKey() {
return key;
}
/**
* Hashed user password
*
* @return MD5 hashed password
*/
public String getVal() {
return val;
}
/**
* Is the user banned by the database
*
* @return users ban status
*/
public boolean isBanned() {
return banned;
}
/**
* Has the user activated his or her account via email
*
* @return if users account is activated or not
*/
public boolean isActivated() {
return active;
}
}
/**
* A single announcement from API
*
* @author AL_1
*
*/
static class Announcement {
private final int id;
private final String message, date;
public Announcement(JsonObject json) {
this.id = Integer.parseInt(json.get("id").asString());
this.message = json.get("message").asString();
this.date = json.get("trn-date").asString();
}
/**
* Unique id of announcement
*
* @return id of announcement
*/
public int getId() {
return id;
}
/**
* Get the content of the announcement
*
* @return message from announcement
*/
public String getMessage() {
return message;
}
/**
* Date and time that the announcement was sent
*
* @return date and time in string format
*/
public String getDate() {
return date;
}
}
/**
* Collection of announcements with original response
*
* @author AL_1
*
*/
class Announcements {
private final Response response;
private List<Announcement> announcements = new ArrayList<>();
/**
* Creates collection of announcements form the Json send by the server
*
* @param json
* Json response from server
*/
public Announcements(JsonObject json) {
this.response = new Response(json);
if (response.getCode() != 0) {
announcements = new ArrayList<>();
} else {
JsonArray jsonAncs = json.get("data").asArray();
for (JsonValue item : jsonAncs)
announcements.add(new Announcement(item.asObject()));
}
}
/**
* Get the standard response object from the API for this collection of
* announcements
*
* @return Standard response
*/
public Response getResponse() {
return response;
}
/**
* Get the collection of announcements within this object
*
* @return List of announcements
*/
public List<Announcement> getAnnouncements() {
return announcements;
}
}
/**
* A single alert from a specific user
*
* @author AL_1
*
*/
static class Alert {
private final int id;
private final String title, message, date;
private boolean isnew;
private User user;
/**
* New alert object
*
* @param json
* Json from data array in response
* @param user
* User associated with alert
*/
public Alert(JsonObject json, User user) {
this.id = Integer.parseInt(json.get("id").asString());
this.message = json.get("message").asString();
this.title = json.get("title").asString();
this.date = json.get("trn_date").asString();
String isnew = json.get("new").asString();
if (isnew.equalsIgnoreCase("yes")) {
this.isnew = true;
} else {
this.isnew = false;
}
}
public Alert(int id, String title, String message, String date, boolean isnew, User user) {
this.id = id;
this.title = title;
this.message = message;
this.date = date;
this.isnew = isnew;
this.user = user;
}
/**
* Id of the alert
*
* @return alert id
*/
public int getId() {
return id;
}
/**
* Gets the content of the alert
*
* @return alert message
*/
public String getMessage() {
return message;
}
/**
* Date and time that the alert was sent
*
* @return date and time in string format
*/
public String getDate() {
return date;
}
/**
* Gets the title of the application/service that sent the alert
*
* @return title of alert
*/
public String getTitle() {
return title;
}
/**
* Get user associated with this alert
*
* @return User object
*/
public User getUser() {
return user;
}
/**
* Check if this alert is new or not
*
* @return if is alert new
*/
public boolean isNew() {
return isnew;
}
}
/**
* Collection of alerts from user with original response
*
* @author AL_1
*
*/
static class Alerts {
private final Response response;
private List<Alert> alerts = new ArrayList<>();
private User user;
/**
* New collection of alerts
*
* @param json
* Json response from server
* @param user
* User associated with alert
*/
public Alerts(JsonObject json, User user) {
this.response = new Response(json);
if (response.getCode() != 0) {
alerts = new ArrayList<>();
} else {
JsonArray jsonAncs = json.get("data").asArray();
for (JsonValue item : jsonAncs) {
alerts.add(new Alert(item.asObject(), user));
}
}
}
/**
* Get the standard response object from the API for this collection of
* alerts
*
* @return Standard response
*/
public Response getResponse() {
return response;
}
/**
* Get the collection of alerts within this object
*
* @return List of alerts
*/
public List<Alert> getAlets() {
return alerts;
}
/**
* Get user associated with these alerts
*
* @return User object
*/
public User getUser() {
return user;
}
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment