Fixed verify command not allowing mentions.

Author: EazyFTW

SpigotAPI/.gitignore

@@ -0,0 +1,7 @@
+*.DS_Store
+*.iml
+.idea/
+.gradle/
+out/
+build/
+build.properties

SpigotAPI/README.md

@@ -0,0 +1,12 @@
+# SpigotAPI
+Standalone Web API for retrieving Information off of SpigotMC!
+
+## How To Host This API
+
+Script: ``java -jar SpigotAPI.jar <Spigot Username> <Spigot Password> <API Token>``
+
+The API Token should be a secure random string that will be needed for accessing this api.
+
+## More Information
+
+This API will allow you to get information about all of the buyers from each of your plugins, information about all the updates of each of your plugins, every single review posted on any of your plugins, and info about all of your resources.

SpigotAPI/build.gradle

@@ -0,0 +1,92 @@
+apply plugin: 'java'
+apply plugin: 'com.github.johnrengelman.shadow'
+apply plugin: 'org.hidetake.ssh'
+
+group = "me.TechsCode"
+version = 1.1
+
+sourceCompatibility = 1.8
+targetCompatibility = 1.8
+
+repositories {
+    maven { url 'https://jitpack.io' }
+
+    jcenter()
+    mavenLocal()
+    mavenCentral()
+}
+
+dependencies {
+    // Server
+    shadow group: 'commons-io', name: 'commons-io', version: '2.6'
+    shadow "com.googlecode.json-simple:json-simple:1.1.1"
+
+    // Client
+    shadow "org.jsoup:jsoup:1.8.3"
+    shadow "net.sourceforge.htmlunit:htmlunit:2.29"
+    shadow "org.nanohttpd:nanohttpd:2.3.1"
+}
+
+def props = new Properties()
+def file = file("build.properties")
+def hasUploadSettings = file.exists();
+
+if(hasUploadSettings){
+    file.withInputStream { props.load(it) }
+}
+
+ssh.remotes {
+    server {
+        host = hasUploadSettings ? props.getProperty("host") : ""
+        port = hasUploadSettings ? Integer.valueOf(props.getProperty("port")) : 22
+        user = hasUploadSettings ? props.getProperty("user") : ""
+        password = hasUploadSettings ? props.getProperty("password") : ""
+    }
+}
+
+ssh.settings {
+    knownHosts = allowAnyHosts
+    dryRun = false
+}
+
+task upload {
+    if(!hasUploadSettings) return;
+
+    doLast {
+        ssh.run {
+            session(ssh.remotes.server) {
+                put from: files('build/SpigotAPI.jar'), into: props.getProperty("location")
+            }
+        }
+    }
+}
+
+
+buildscript {
+    repositories {
+        jcenter()
+    }
+    dependencies {
+        classpath 'com.github.jengelman.gradle.plugins:shadow:4.0.4'
+        classpath 'org.hidetake:gradle-ssh-plugin:2.10.1'
+    }
+}
+
+shadowJar {
+    archiveName = 'SpigotAPI.jar'
+    destinationDir = new File("build")
+
+    dependsOn 'build'
+    configurations = [project.configurations.shadow]
+}
+
+jar {
+    manifest {
+        attributes 'Class-Path': '/libs/a.jar'
+        attributes 'Main-Class': 'me.TechsCode.SpigotAPI.server.SpigotAPIServer'
+    }
+}
+
+tasks.withType(JavaCompile) {
+    options.encoding = 'UTF-8'
+}

SpigotAPI/build.properties.template

@@ -0,0 +1,8 @@
+# SSH Credentials for direct uploading after compiling
+host=somehost.com
+port=22
+user=someuser
+password=somepassword
+
+# Export Location on Server
+location=/path/to/folder

SpigotAPI/src/main/java/me/TechsCode/SpigotAPI/client/APIScanner.java

@@ -0,0 +1,92 @@
+package me.TechsCode.SpigotAPI.client;
+
+import me.TechsCode.SpigotAPI.client.objects.*;
+import me.TechsCode.SpigotAPI.logging.Logger;
+import org.apache.commons.io.IOUtils;
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+import org.json.simple.parser.JSONParser;
+
+import java.net.URI;
+import java.nio.charset.StandardCharsets;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+public class APIScanner {
+
+    private SpigotAPIClient client;
+    private String url;
+    private String token;
+
+    private APIStatus status;
+
+    public APIScanner(SpigotAPIClient client, String url, String token) {
+        this.client = client;
+        this.url = url;
+        this.token = token;
+        this.status = APIStatus.WAITING;
+    }
+
+    public Data retrieveData() {
+        JSONObject data;
+
+        try {
+            JSONParser parser = new JSONParser();
+            String json = IOUtils.toString(new URI(url + "/?token=" + token), StandardCharsets.UTF_8);
+            JSONObject root = (JSONObject) parser.parse(json);
+
+            String status = (String) root.get("status");
+            if(!status.equalsIgnoreCase("success")){
+                Logger.log("API returned error message:");
+                System.out.println(root.get("message"));
+                this.status = APIStatus.WAITING;
+                return null;
+            }
+            data = (JSONObject) root.get("data");
+        } catch (Exception e) {
+            Logger.log("Could not reach SpigotAPI on " + url);
+            this.status = APIStatus.OFF;
+            return null;
+        }
+
+        this.status = APIStatus.OK;
+
+        Resource[] resources = getChilds(data.get("resources")).map(item -> new Resource(client, item)).toArray(Resource[]::new);
+        Purchase[] purchases = getChilds(data.get("purchases")).map(item -> new Purchase(client, item)).toArray(Purchase[]::new);
+        Review[] reviews = getChilds(data.get("reviews")).map(item -> new Review(client, item)).toArray(Review[]::new);
+        Update[] updates = getChilds(data.get("updates")).map(item -> new Update(client, item)).toArray(Update[]::new);
+
+        return new Data(System.currentTimeMillis(), resources, purchases, reviews, updates);
+    }
+
+    private Stream<JSONObject> getChilds(Object object) {
+        JSONArray jsonArray = (JSONArray) object;
+        return IntStream.rangeClosed(0, jsonArray.size() - 1).mapToObj(i -> (JSONObject) jsonArray.get(i)).collect(Collectors.toList()).stream();
+    }
+
+    public APIStatus getStatus() {
+        return status;
+    }
+
+    public enum APIStatus {
+        OK("Online", "The api is currently running with no issues!"),
+        WAITING("Gathering Info", "The api is currently gathering information. This usually takes around 5-10 mins."),
+        OFF("Offline", "The api is offline and it cannot even fetch the url!");
+
+        private String name, description;
+
+        APIStatus(String name, String description) {
+            this.name = name;
+            this.description = description;
+        }
+
+        public String getName() {
+            return name;
+        }
+
+        public String getDescription() {
+            return description;
+        }
+    }
+}

SpigotAPI/src/main/java/me/TechsCode/SpigotAPI/client/DataManager.java

@@ -0,0 +1,27 @@
+package me.TechsCode.SpigotAPI.client;
+
+import me.TechsCode.SpigotAPI.client.objects.Data;
+
+import java.util.concurrent.TimeUnit;
+
+public class DataManager extends Thread {
+
+    private static final long REFRESH_DELAY = TimeUnit.MINUTES.toMillis(15);
+    private long timeout = 0;
+
+    private APIScanner apiEndpoint;
+    private Data latest;
+
+    public DataManager(APIScanner apiEndpoint) {
+        this.apiEndpoint = apiEndpoint;
+        this.latest = null;
+
+        start();
+    }
+
+    public Data getData(){
+        return latest;
+    }
+}
+
+

SpigotAPI/src/main/java/me/TechsCode/SpigotAPI/client/SpigotAPIClient.java

@@ -0,0 +1,85 @@
+package me.TechsCode.SpigotAPI.client;
+
+import me.TechsCode.SpigotAPI.client.collections.PurchaseCollection;
+import me.TechsCode.SpigotAPI.client.collections.ResourceCollection;
+import me.TechsCode.SpigotAPI.client.collections.ReviewCollection;
+import me.TechsCode.SpigotAPI.client.collections.UpdateCollection;
+import me.TechsCode.SpigotAPI.client.objects.*;
+import me.TechsCode.SpigotAPI.logging.ConsoleColor;
+import me.TechsCode.SpigotAPI.logging.Logger;
+
+import java.util.concurrent.TimeUnit;
+
+public class SpigotAPIClient extends Thread {
+
+    private static final long REFRESH_DELAY = TimeUnit.MINUTES.toMillis(1);
+    private long timeout = 0;
+
+    private APIScanner scanner;
+    private Data latest;
+
+    private APIScanner.APIStatus cacheStatus;
+
+    public SpigotAPIClient(String url, String token){
+        Logger.log("Connecting to SpigotAPI instance on " + url);
+        scanner = new APIScanner(this, url, token);
+
+        cacheStatus = APIScanner.APIStatus.WAITING;
+
+        retrieveData();
+        start();
+    }
+
+    private void retrieveData() {
+        Data latest2 = scanner.retrieveData();
+
+        if(latest2 == null) {
+            Logger.log(ConsoleColor.RED + " Could not retrieve new data.. Waiting 5 minutes.. (NEW: Saving old data)");
+            timeout = System.currentTimeMillis() + TimeUnit.MINUTES.toMillis(5);
+            if(latest == null) cacheStatus = scanner.getStatus();
+        } else {
+            latest = latest2;
+            cacheStatus = APIScanner.APIStatus.OK;
+        }
+    }
+
+    @Override
+    public void run() {
+        while (true) {
+            if(timeout != 0 && timeout > System.currentTimeMillis()) continue;
+
+            if(latest == null || (System.currentTimeMillis() - latest.getRetrievedTime()) > REFRESH_DELAY) {
+                retrieveData();
+            }
+        }
+    }
+
+    public ResourceCollection getResources() {
+        return new ResourceCollection(isAvailable() ? latest.getResources() : new Resource[0]);
+    }
+
+    public PurchaseCollection getPurchases() {
+        return new PurchaseCollection(isAvailable() ? latest.getPurchases() : new Purchase[0]);
+    }
+
+    public ReviewCollection getReviews() {
+        return new ReviewCollection(isAvailable() ? latest.getReviews() : new Review[0]);
+    }
+
+    public UpdateCollection getUpdates() {
+        return new UpdateCollection(isAvailable() ? latest.getUpdates() : new Update[0]);
+    }
+
+    public boolean isAvailable() {
+        if(latest == null) return false;
+        return latest.getPurchases() != null;
+    }
+
+    public APIScanner.APIStatus getStatus() {
+        return scanner.getStatus();
+    }
+
+    public APIScanner.APIStatus getCacheStatus() {
+        return cacheStatus;
+    }
+}

SpigotAPI/src/main/java/me/TechsCode/SpigotAPI/client/collections/PurchaseCollection.java

@@ -0,0 +1,60 @@
+package me.TechsCode.SpigotAPI.client.collections;
+
+import me.TechsCode.SpigotAPI.client.objects.Purchase;
+import me.TechsCode.SpigotAPI.client.objects.Resource;
+
+import java.util.Arrays;
+import java.util.stream.Stream;
+
+public class PurchaseCollection {
+
+    private Purchase[] array;
+
+    public PurchaseCollection(Purchase[] array) {
+        this.array = array;
+    }
+
+    public PurchaseCollection resource(Resource resource){
+        return resourceId(resource.getId());
+    }
+
+    public PurchaseCollection resourceName(String resourceName){
+        return new PurchaseCollection(getStream().filter(x -> x.getResourceName().equalsIgnoreCase(resourceName)).toArray(Purchase[]::new));
+    }
+
+    public PurchaseCollection resourceId(String resourceId){
+        return new PurchaseCollection(getStream().filter(x -> x.getResourceId().equalsIgnoreCase(resourceId)).toArray(Purchase[]::new));
+    }
+
+    public PurchaseCollection username(String username){
+        return new PurchaseCollection(getStream().filter(x -> x.getUsername().equalsIgnoreCase(username)).toArray(Purchase[]::new));
+    }
+
+    public PurchaseCollection userId(String userId){
+        return new PurchaseCollection(getStream().filter(x -> x.getUserId().equalsIgnoreCase(userId)).toArray(Purchase[]::new));
+    }
+
+    public PurchaseCollection older(long time){
+        return new PurchaseCollection(getStream().filter(x -> x.getTime().getUnixTime() > time).toArray(Purchase[]::new));
+    }
+
+    public PurchaseCollection newer(long time){
+        return new PurchaseCollection(getStream().filter(x -> x.getTime().getUnixTime() < time).toArray(Purchase[]::new));
+    }
+
+    public Stream<Purchase> getStream(){
+        return Arrays.stream(array);
+    }
+
+    public Purchase[] get(){
+        return array;
+    }
+
+    public Purchase first(){
+        return array[0];
+    }
+
+    public int size(){
+        return array.length;
+    }
+}