--- /dev/null
+<project name="MarketUploader" default="jar">
+ <property name="src" location="."/>
+ <property name="build" location="build"/>
+ <property name="rootdir" location="."/>
+
+ <target name="init">
+ <mkdir dir="${build}"/>
+ </target>
+
+ <target name="compile" depends="init">
+ <javac srcdir="${src}"
+ destdir="${build}"
+ classpath="${src}"
+ debug="true"
+ debuglevel="lines,vars,source">
+ <compilerarg value="-Xlint:unchecked"/>
+ </javac>
+ </target>
+
+ <target name="jar" depends="compile">
+ <jar jarfile="${build}/PCTB-ControlPanel.jar">
+ <manifest>
+ <attribute name="Main-Class" value="com.tedpearson.ypp.market.ControlPanel"/>
+ </manifest>
+ <fileset dir="${build}" includes="**/ControlPanel*"/>
+ </jar>
+ <jar jarfile="${build}/PCTB-Uploader.jar">
+ <fileset dir="${src}" includes="com/sun/**" />
+ <fileset dir="${build}" includes="**/Market*.class"/>
+ <fileset dir="${build}" includes="com/myjavatools/**, com/tedpearson/util/update/*.class"/>
+ </jar>
+ <jar jarfile="${rootdir}/PCTB-Installer.jar">
+ <manifest>
+ <attribute name="Main-Class" value="com.tedpearson.ypp.market.Installer"/>
+ </manifest>
+ <fileset dir="${build}" includes="**/Installer*.class, *.jar" excludes="ControlPanel*"/>
+ <fileset dir="${build}" includes="com/tedpearson/util/update/*.class"/>
+ <zipfileset prefix="lib" dir="${src}" includes="elevate.*"/>
+ <zipfileset prefix="src" dir="${rootdir}" includes="com/tedpearson/ypp/market/*.java, com/tedpearson/util/update/*.java, com/myjavatools/web/*.java, PCTB.xml"/>
+ </jar>
+
+ </target>
+
+ <target name="run" depends="jar">
+ <java jar="${rootdir}/PCTB-Installer.jar" fork="true"/>
+ </target>
+</project>
--- /dev/null
+package com.myjavatools.web;
+
+import java.net.URLConnection;
+import java.net.URL;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.io.File;
+import java.io.InputStream;
+import java.util.Random;
+import java.io.OutputStream;
+import java.io.FileInputStream;
+import java.util.Iterator;
+
+/**
+ * <p>Title: Client HTTP Request class</p>
+ * <p>Description: this class helps to send POST HTTP requests with various form data,
+ * including files. Cookies can be added to be included in the request.</p>
+ * <p>Modified by Ted Pearson(ted@tedpearson.com) 5/4/09</p>
+ *
+ * @author Vlad Patryshev
+ * @version 1.0
+ */
+public class ClientHttpRequest {
+ URLConnection connection;
+ OutputStream os = null;
+ Map cookies = new HashMap();
+
+ protected void connect() throws IOException {
+ if (os == null) os = connection.getOutputStream();
+ }
+
+ protected void write(char c) throws IOException {
+ connect();
+ os.write(c);
+ }
+
+ protected void write(String s) throws IOException {
+ connect();
+ os.write(s.getBytes());
+ }
+
+ protected void newline() throws IOException {
+ connect();
+ write("\r\n");
+ }
+
+ protected void writeln(String s) throws IOException {
+ connect();
+ write(s);
+ newline();
+ }
+
+ private static Random random = new Random();
+
+ protected static String randomString() {
+ return Long.toString(random.nextLong(), 36);
+ }
+
+ String boundary = "---------------------------" + randomString() + randomString() + randomString();
+
+ private void boundary() throws IOException {
+ write("--");
+ write(boundary);
+ }
+
+ /**
+ * Creates a new multipart POST HTTP request on a freshly opened URLConnection
+ *
+ * @param connection an already open URL connection
+ * @throws IOException
+ */
+ public ClientHttpRequest(URLConnection connection) throws IOException {
+ this.connection = connection;
+ connection.setDoOutput(true);
+ connection.setRequestProperty("Content-Type",
+ "multipart/form-data; boundary=" + boundary);
+ }
+
+ /**
+ * Creates a new multipart POST HTTP request for a specified URL
+ *
+ * @param url the URL to send request to
+ * @throws IOException
+ */
+ public ClientHttpRequest(URL url) throws IOException {
+ this(url.openConnection());
+ }
+
+ /**
+ * Creates a new multipart POST HTTP request for a specified URL string
+ *
+ * @param urlString the string representation of the URL to send request to
+ * @throws IOException
+ */
+ public ClientHttpRequest(String urlString) throws IOException {
+ this(new URL(urlString));
+ }
+
+
+ private void postCookies() {
+ StringBuffer cookieList = new StringBuffer();
+
+ for (Iterator i = cookies.entrySet().iterator(); i.hasNext();) {
+ Map.Entry entry = (Map.Entry)(i.next());
+ cookieList.append(entry.getKey().toString() + "=" + entry.getValue());
+
+ if (i.hasNext()) {
+ cookieList.append("; ");
+ }
+ }
+ if (cookieList.length() > 0) {
+ connection.setRequestProperty("Cookie", cookieList.toString());
+ }
+ }
+
+ /**
+ * adds a cookie to the requst
+ * @param name cookie name
+ * @param value cookie value
+ * @throws IOException
+ */
+ public void setCookie(String name, String value) throws IOException {
+ cookies.put(name, value);
+ }
+
+ /**
+ * adds cookies to the request
+ * @param cookies the cookie "name-to-value" map
+ * @throws IOException
+ */
+ public void setCookies(Map cookies) throws IOException {
+ if (cookies == null) return;
+ this.cookies.putAll(cookies);
+ }
+
+ /**
+ * adds cookies to the request
+ * @param cookies array of cookie names and values (cookies[2*i] is a name, cookies[2*i + 1] is a value)
+ * @throws IOException
+ */
+ public void setCookies(String[] cookies) throws IOException {
+ if (cookies == null) return;
+ for (int i = 0; i < cookies.length - 1; i+=2) {
+ setCookie(cookies[i], cookies[i+1]);
+ }
+ }
+
+ private void writeName(String name) throws IOException {
+ newline();
+ write("Content-Disposition: form-data; name=\"");
+ write(name);
+ write('"');
+ }
+
+ /**
+ * adds a string parameter to the request
+ * @param name parameter name
+ * @param value parameter value
+ * @throws IOException
+ */
+ public void setParameter(String name, String value) throws IOException {
+ boundary();
+ writeName(name);
+ newline(); newline();
+ writeln(value);
+ }
+
+ private static void pipe(InputStream in, OutputStream out) throws IOException {
+ byte[] buf = new byte[500000];
+ int nread;
+ int navailable;
+ int total = 0;
+ synchronized (in) {
+ while((nread = in.read(buf, 0, buf.length)) >= 0) {
+ out.write(buf, 0, nread);
+ total += nread;
+ }
+ }
+ out.flush();
+ buf = null;
+ }
+
+ /**
+ * adds a file parameter to the request
+ * @param name parameter name
+ * @param filename the name of the file
+ * @param is input stream to read the contents of the file from
+ * @throws IOException
+ */
+ public void setParameter(String name, String filename, InputStream is) throws IOException {
+ String type = connection.guessContentTypeFromName(filename);
+ if (type == null) type = "application/octet-stream";
+ setParameter(name, filename, is, type);
+ }
+
+ /**
+ * adds a file parameter to the request
+ * @param name parameter name
+ * @param filename the name of the file
+ * @param is input stream to read the contents of the file from
+ * @param type Content-Type of the file
+ * @throws IOException
+ */
+ public void setParameter(String name, String filename, InputStream is, String type) throws IOException {
+ boundary();
+ writeName(name);
+ write("; filename=\"");
+ write(filename);
+ write('"');
+ newline();
+ write("Content-Type: ");
+ writeln(type);
+ newline();
+ pipe(is, os);
+ newline();
+ }
+
+ /**
+ * adds a file parameter to the request
+ * @param name parameter name
+ * @param file the file to upload
+ * @throws IOException
+ */
+ public void setParameter(String name, File file) throws IOException {
+ setParameter(name, file.getPath(), new FileInputStream(file));
+ }
+
+ /**
+ * adds a parameter to the request; if the parameter is a File, the file is uploaded, otherwise the string value of the parameter is passed in the request
+ * @param name parameter name
+ * @param object parameter value, a File or anything else that can be stringified
+ * @throws IOException
+ */
+ public void setParameter(String name, Object object) throws IOException {
+ if (object instanceof File) {
+ setParameter(name, (File) object);
+ } else {
+ setParameter(name, object.toString());
+ }
+ }
+
+ /**
+ * adds parameters to the request
+ * @param parameters "name-to-value" map of parameters; if a value is a file, the file is uploaded, otherwise it is stringified and sent in the request
+ * @throws IOException
+ */
+ public void setParameters(Map parameters) throws IOException {
+ if (parameters == null) return;
+ for (Iterator i = parameters.entrySet().iterator(); i.hasNext();) {
+ Map.Entry entry = (Map.Entry)i.next();
+ setParameter(entry.getKey().toString(), entry.getValue());
+ }
+ }
+
+ /**
+ * adds parameters to the request
+ * @param parameters array of parameter names and values (parameters[2*i] is a name, parameters[2*i + 1] is a value); if a value is a file, the file is uploaded, otherwise it is stringified and sent in the request
+ * @throws IOException
+ */
+ public void setParameters(Object[] parameters) throws IOException {
+ if (parameters == null) return;
+ for (int i = 0; i < parameters.length - 1; i+=2) {
+ setParameter(parameters[i].toString(), parameters[i+1]);
+ }
+ }
+
+ /**
+ * posts the requests to the server, with all the cookies and parameters that were added
+ * @return input stream with the server response
+ * @throws IOException
+ */
+ public InputStream post() throws IOException {
+ boundary();
+ writeln("--");
+ os.close();
+ InputStream tis;
+ try {
+ tis = connection.getInputStream();
+ } catch (IOException e) {
+ tis = ((java.net.HttpURLConnection) connection).getErrorStream();
+ }
+ return tis;
+ }
+
+ /**
+ * posts the requests to the server, with all the cookies and parameters that were added before (if any), and with parameters that are passed in the argument
+ * @param parameters request parameters
+ * @return input stream with the server response
+ * @throws IOException
+ * @see setParameters
+ */
+ public InputStream post(Map parameters) throws IOException {
+ setParameters(parameters);
+ return post();
+ }
+
+ /**
+ * posts the requests to the server, with all the cookies and parameters that were added before (if any), and with parameters that are passed in the argument
+ * @param parameters request parameters
+ * @return input stream with the server response
+ * @throws IOException
+ * @see setParameters
+ */
+ public InputStream post(Object[] parameters) throws IOException {
+ setParameters(parameters);
+ return post();
+ }
+
+ /**
+ * posts the requests to the server, with all the cookies and parameters that were added before (if any), and with cookies and parameters that are passed in the arguments
+ * @param cookies request cookies
+ * @param parameters request parameters
+ * @return input stream with the server response
+ * @throws IOException
+ * @see setParameters
+ * @see setCookies
+ */
+ public InputStream post(Map cookies, Map parameters) throws IOException {
+ setCookies(cookies);
+ setParameters(parameters);
+ return post();
+ }
+
+ /**
+ * posts the requests to the server, with all the cookies and parameters that were added before (if any), and with cookies and parameters that are passed in the arguments
+ * @param cookies request cookies
+ * @param parameters request parameters
+ * @return input stream with the server response
+ * @throws IOException
+ * @see setParameters
+ * @see setCookies
+ */
+ public InputStream post(String[] cookies, Object[] parameters) throws IOException {
+ setCookies(cookies);
+ setParameters(parameters);
+ return post();
+ }
+
+ /**
+ * post the POST request to the server, with the specified parameter
+ * @param name parameter name
+ * @param value parameter value
+ * @return input stream with the server response
+ * @throws IOException
+ * @see setParameter
+ */
+ public InputStream post(String name, Object value) throws IOException {
+ setParameter(name, value);
+ return post();
+ }
+
+ /**
+ * post the POST request to the server, with the specified parameters
+ * @param name1 first parameter name
+ * @param value1 first parameter value
+ * @param name2 second parameter name
+ * @param value2 second parameter value
+ * @return input stream with the server response
+ * @throws IOException
+ * @see setParameter
+ */
+ public InputStream post(String name1, Object value1, String name2, Object value2) throws IOException {
+ setParameter(name1, value1);
+ return post(name2, value2);
+ }
+
+ /**
+ * post the POST request to the server, with the specified parameters
+ * @param name1 first parameter name
+ * @param value1 first parameter value
+ * @param name2 second parameter name
+ * @param value2 second parameter value
+ * @param name3 third parameter name
+ * @param value3 third parameter value
+ * @return input stream with the server response
+ * @throws IOException
+ * @see setParameter
+ */
+ public InputStream post(String name1, Object value1, String name2, Object value2, String name3, Object value3) throws IOException {
+ setParameter(name1, value1);
+ return post(name2, value2, name3, value3);
+ }
+
+ /**
+ * post the POST request to the server, with the specified parameters
+ * @param name1 first parameter name
+ * @param value1 first parameter value
+ * @param name2 second parameter name
+ * @param value2 second parameter value
+ * @param name3 third parameter name
+ * @param value3 third parameter value
+ * @param name4 fourth parameter name
+ * @param value4 fourth parameter value
+ * @return input stream with the server response
+ * @throws IOException
+ * @see setParameter
+ */
+ public InputStream post(String name1, Object value1, String name2, Object value2, String name3, Object value3, String name4, Object value4) throws IOException {
+ setParameter(name1, value1);
+ return post(name2, value2, name3, value3, name4, value4);
+ }
+
+ /**
+ * posts a new request to specified URL, with parameters that are passed in the argument
+ * @param parameters request parameters
+ * @return input stream with the server response
+ * @throws IOException
+ * @see setParameters
+ */
+ public static InputStream post(URL url, Map parameters) throws IOException {
+ return new ClientHttpRequest(url).post(parameters);
+ }
+
+ /**
+ * posts a new request to specified URL, with parameters that are passed in the argument
+ * @param parameters request parameters
+ * @return input stream with the server response
+ * @throws IOException
+ * @see setParameters
+ */
+ public static InputStream post(URL url, Object[] parameters) throws IOException {
+ return new ClientHttpRequest(url).post(parameters);
+ }
+
+ /**
+ * posts a new request to specified URL, with cookies and parameters that are passed in the argument
+ * @param cookies request cookies
+ * @param parameters request parameters
+ * @return input stream with the server response
+ * @throws IOException
+ * @see setCookies
+ * @see setParameters
+ */
+ public static InputStream post(URL url, Map cookies, Map parameters) throws IOException {
+ return new ClientHttpRequest(url).post(cookies, parameters);
+ }
+
+ /**
+ * posts a new request to specified URL, with cookies and parameters that are passed in the argument
+ * @param cookies request cookies
+ * @param parameters request parameters
+ * @return input stream with the server response
+ * @throws IOException
+ * @see setCookies
+ * @see setParameters
+ */
+ public static InputStream post(URL url, String[] cookies, Object[] parameters) throws IOException {
+ return new ClientHttpRequest(url).post(cookies, parameters);
+ }
+
+ /**
+ * post the POST request specified URL, with the specified parameter
+ * @param name parameter name
+ * @param value parameter value
+ * @return input stream with the server response
+ * @throws IOException
+ * @see setParameter
+ */
+ public static InputStream post(URL url, String name1, Object value1) throws IOException {
+ return new ClientHttpRequest(url).post(name1, value1);
+ }
+
+ /**
+ * post the POST request to specified URL, with the specified parameters
+ * @param name1 first parameter name
+ * @param value1 first parameter value
+ * @param name2 second parameter name
+ * @param value2 second parameter value
+ * @return input stream with the server response
+ * @throws IOException
+ * @see setParameter
+ */
+ public static InputStream post(URL url, String name1, Object value1, String name2, Object value2) throws IOException {
+ return new ClientHttpRequest(url).post(name1, value1, name2, value2);
+ }
+
+ /**
+ * post the POST request to specified URL, with the specified parameters
+ * @param name1 first parameter name
+ * @param value1 first parameter value
+ * @param name2 second parameter name
+ * @param value2 second parameter value
+ * @param name3 third parameter name
+ * @param value3 third parameter value
+ * @return input stream with the server response
+ * @throws IOException
+ * @see setParameter
+ */
+ public static InputStream post(URL url, String name1, Object value1, String name2, Object value2, String name3, Object value3) throws IOException {
+ return new ClientHttpRequest(url).post(name1, value1, name2, value2, name3, value3);
+ }
+
+ /**
+ * post the POST request to specified URL, with the specified parameters
+ * @param name1 first parameter name
+ * @param value1 first parameter value
+ * @param name2 second parameter name
+ * @param value2 second parameter value
+ * @param name3 third parameter name
+ * @param value3 third parameter value
+ * @param name4 fourth parameter name
+ * @param value4 fourth parameter value
+ * @return input stream with the server response
+ * @throws IOException
+ * @see setParameter
+ */
+ public static InputStream post(URL url, String name1, Object value1, String name2, Object value2, String name3, Object value3, String name4, Object value4) throws IOException {
+ return new ClientHttpRequest(url).post(name1, value1, name2, value2, name3, value3, name4, value4);
+ }
+}
--- /dev/null
+package com.tedpearson.util.update;
+
+import java.net.*;
+import java.io.*;
+import java.util.prefs.*;
+import java.awt.Component;
+import javax.swing.JOptionPane;
+import javax.swing.*;
+
+/*
+ TODO:
+ show update window with progress bar when updating (optionally)
+*/
+
+public class Updater {
+ private int version = -1;
+ private URL downloadURL;
+ private static Updater updater = new Updater();
+
+ public static Updater getUpdater() {
+ return updater;
+ }
+
+ public boolean checkForUpdate(
+ Component parentComponent,
+ String updateUrl,
+ int currentVersion) {
+ return checkForUpdate(parentComponent, updateUrl, "this program", currentVersion, true);
+ }
+
+
+ /**
+ * Just check to see if there is an update.
+ */
+ public boolean checkForUpdate(
+ Component parentComponent,
+ String updateUrl,
+ String program,
+ int currentVersion,
+ boolean promptUser) {
+ String node = "com/tedpearson/update";
+ Preferences prefs = Preferences.userRoot().node(node);
+ String update = prefs.get(updateUrl,"");
+ if(update.equals("Never")) {
+ return false;
+ }
+ if(!update.equals("Yes")) {
+ if(!promptUser) {
+ return false;
+ }
+ // first, confirm user wants to allow updates
+ int option = JOptionPane.showOptionDialog(parentComponent,
+ "Do you want to let " + program + " check for updates when it opens?",
+ "Check for Updates?",
+ 0, JOptionPane.QUESTION_MESSAGE,
+ null, new String[] {"Yes","This Time","Not Now","Never"},"Yes");
+ switch(option) {
+ case 2:
+ return false;
+ case 3:
+ prefs.put(updateUrl,"Never");
+ return false;
+ case 0:
+ prefs.put(updateUrl,"Yes");
+ case 1:
+ }
+ }
+ // query the server to check the version number
+ accessVersion(parentComponent, updateUrl);
+ // System.out.println(version+","+currentVersion);
+ if(version > currentVersion) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ public void checkAndUpdate(
+ Component parentComponent,
+ String updateUrl,
+ String program,
+ int currentVersion,
+ boolean promptUser,
+ String jar) {
+ if(checkForUpdate(parentComponent, updateUrl, program, currentVersion, promptUser)) {
+ updateJar(parentComponent, updateUrl, currentVersion, promptUser, jar);
+ }
+ }
+
+ public void checkAndUpdate(
+ Component parentComponent,
+ String updateUrl,
+ int currentVersion) {
+ if(checkForUpdate(parentComponent, updateUrl, currentVersion)) {
+ updateJar(parentComponent, updateUrl, currentVersion);
+ }
+ }
+
+ public void updateJar(
+ Component parentComponent,
+ String updateUrl,
+ int currentVersion) {
+ updateJar(parentComponent, updateUrl, currentVersion, true, null);
+ }
+
+ public void updateJar(
+ Component parentComponent,
+ String updateUrl,
+ int currentVersion,
+ boolean promptUser,
+ String jar) {
+ try {
+ accessVersion(parentComponent, updateUrl);
+ // download new version
+ File temp = File.createTempFile("com.tedpearson.updater.download",null);
+ temp.deleteOnExit();
+ URLConnection conn = downloadURL.openConnection();
+ ProgressMonitorInputStream pmis = new ProgressMonitorInputStream(
+ parentComponent,
+ "Downloading program update",
+ conn.getInputStream()
+ );
+ ProgressMonitor pm = pmis.getProgressMonitor();
+ pm.setMillisToDecideToPopup(0);
+ pm.setMillisToPopup(0);
+ if(!promptUser) {
+ pm.setMillisToDecideToPopup(Integer.MAX_VALUE);
+ pm.setMillisToPopup(Integer.MAX_VALUE);
+ }
+ pm.setMaximum(conn.getHeaderFieldInt("Content-Length",0));
+ copyFile(pmis, new FileOutputStream(temp));
+ // replace old with new.
+ if(jar == null) {
+ jar = getClass().getProtectionDomain().getCodeSource().getLocation().getPath();
+ }
+ jar = jar.replaceAll("%20"," ");
+ copyFile(new FileInputStream(temp), new FileOutputStream(new File(jar)));
+ // remove temp file
+ temp.delete();
+ // launch new version and quit this one.
+ ProcessBuilder pb = new ProcessBuilder("java","-jar",jar);
+ pb.start();
+ System.exit(0);
+ // no new version
+ } catch(Exception e) {
+ // errors.
+ e.printStackTrace();
+ // show error here.
+ if(promptUser) {
+ JOptionPane.showMessageDialog(parentComponent, "There was an error while trying to update.",
+ "Error", JOptionPane.ERROR_MESSAGE);
+ }
+ }
+ }
+
+ private void accessVersion(Component parentComponent, String updateUrl) {
+ if(version != -1) return;
+ try {
+ URL url = new URL(updateUrl);
+ BufferedReader br = new BufferedReader(new InputStreamReader(url.openStream()));
+ version = Integer.parseInt(br.readLine());
+ downloadURL = new URL(br.readLine());
+ } catch(Exception e) {
+ // errors.
+ e.printStackTrace();
+ // show error here.
+ JOptionPane.showMessageDialog(parentComponent, "There was an error while trying to update.",
+ "Error", JOptionPane.ERROR_MESSAGE);
+ }
+ }
+
+ /**
+ * Utility method to copy a file. I can't believe java doesn't have anything
+ * built-in to do something this simple with less code. Other than channels, that is.
+ *
+ * @param in stream to read file from
+ * @param out stream to write file to
+ */
+ public static void copyFile(InputStream in, OutputStream out) throws IOException {
+ byte[] buf = new byte[1024];
+ int len;
+ while ((len = in.read(buf)) > 0) {
+ out.write(buf, 0, len);
+
+ }
+ in.close();
+ out.close();
+ }
+}
\ No newline at end of file
--- /dev/null
+package com.tedpearson.ypp.market;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.*;
+import java.util.prefs.*;
+
+/**
+* ControlPanel is a simple management utility that sets
+* a preference for whether the PCTB client is to launch or not.
+*/
+public class ControlPanel extends JFrame {
+ public static void main(String[] args) {
+ new ControlPanel();
+ }
+
+ public ControlPanel() {
+ super("PCTB Control Panel");
+ final Preferences prefs = Preferences.userNodeForPackage(getClass());
+ final JCheckBox cb = new JCheckBox("Launch PCTB Uploader when YPP starts?", prefs.getBoolean("launchAtStartup", true));
+ final JCheckBox toPCTB = new JCheckBox("Upload to PCTB?", prefs.getBoolean("uploadToPCTB", true));
+ final JCheckBox toYarrg = new JCheckBox("Upload to Yarrg?", prefs.getBoolean("uploadToYarrg", true));
+
+ final JRadioButton live = new JRadioButton("Use live servers");
+ final JRadioButton testing = new JRadioButton("Use testing servers");
+
+ live.setSelected(prefs.getBoolean("useLiveServers", false));
+ testing.setSelected(!prefs.getBoolean("useLiveServers", false));
+
+ ButtonGroup liveortest = new ButtonGroup();
+ liveortest.add(live);
+ liveortest.add(testing);
+
+ setLayout(new GridLayout(6,1));
+ add(cb);
+ add(toPCTB);
+ add(toYarrg);
+ add(live);
+ add(testing);
+
+ JButton but = new JButton("Save");
+ add(but);
+ but.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent e) {
+ prefs.putBoolean("launchAtStartup", cb.isSelected());
+ prefs.putBoolean("uploadToPCTB", toPCTB.isSelected());
+ prefs.putBoolean("uploadToYarrg", toYarrg.isSelected());
+ prefs.putBoolean("useLiveServers", live.isSelected());
+ System.exit(0);
+ }
+ });
+ pack();
+ setLocationRelativeTo(null);
+ setVisible(true);
+ setSize(getWidth() + 10, getHeight() + 10);
+ setDefaultCloseOperation(EXIT_ON_CLOSE);
+ getRootPane().setDefaultButton(but);
+ }
+}
--- /dev/null
+package com.tedpearson.ypp.market;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.border.*;
+import java.io.*;
+import com.tedpearson.util.update.*;
+import java.util.Properties;
+import java.net.URLDecoder;
+
+/*
+ allow adding islands/oceans
+ implement uploads to YAARG
+*/
+
+/**
+* An Installer for PCTB Java Client.
+*/
+public class Installer extends JFrame {
+ public final static int VERSION = 8;
+ private JLabel label;
+ private JProgressBar progress;
+ private JButton install, uninstall;
+ private static String os = System.getProperty("os.name");
+ private static String home = System.getProperty("java.home");
+ private static String user_home = System.getProperty("user.home");
+ private boolean installed = false;
+ private boolean uninstalled = false;
+ private static PrintWriter pw;
+
+ public static void debug(String str) {
+ try {
+ pw.println(str);
+ pw.flush();
+ }catch(Exception e) {
+
+ }
+ }
+
+ public static void main(String[] args) {
+ /*
+ try{
+ pw = new PrintWriter("C:/Users/Public/ERRORS");
+ }catch(Exception e) {
+
+ }
+ */
+ new Installer(args);
+ }
+
+ /**
+ * Checks if we have permission to write to the Java Home folder
+ * that runs YPP. Pops up an error message and exits if we don't have access,
+ * or on Mac OS X, re-runs the installer using applescript to authenticate.
+ */
+ private void checkPermission(String[] args) {
+ File a11y = null;
+ a11y = new File(getJavaHome(),"lib");
+ if(os.equals("Mac OS X")) {
+ if(!a11y.canWrite()) {
+ JOptionPane.showMessageDialog(null,"Please authenticate as an Administrator, when prompted, to continue installation.");
+ try {
+ String installer = URLDecoder.decode(getClass().getProtectionDomain().getCodeSource().getLocation()
+ .getPath(), "URT-8");
+ Runtime.getRuntime().exec(new String[]{"osascript","-e","do shell script \"java -jar " +
+ installer + "\" with administrator privileges"});
+ } catch(Exception e) {
+ e.printStackTrace();
+ }
+ System.exit(0);
+ }
+ } else {
+ // clean up after myself
+ if(os.contains("Vista")) {
+ File tempDir = new File(System.getProperty("java.io.tmpdir"));
+ for(File f : tempDir.listFiles()) {
+ if(f.getName().startsWith("PCTB-lib")) {
+ for(File g : f.listFiles()) {
+ g.delete();
+ }
+ f.delete();
+ }
+ }
+ }
+ // first check for YPP java
+ boolean canWrite = true;
+ File test = new File(a11y, "test_pctb");
+ try {
+ test.createNewFile();
+ test.delete();
+ } catch(IOException e) {
+ canWrite = false;
+ }
+ if(!canWrite || !a11y.canWrite()) {
+ if(os.contains("Vista")) {
+ if(args.length == 1 && args[0].equals("--elevate")) {
+ JOptionPane.showMessageDialog(null,"Please run this installer while logged in as an Administrator.");
+ System.exit(0);
+ }
+ try {
+ String installer = URLDecoder.decode(getClass().getProtectionDomain().getCodeSource().getLocation()
+ .getPath(), "UTF-8").replaceFirst("/","");
+ ProcessBuilder pb = new ProcessBuilder("cmd.exe", "/C", "elevate javaw -jar \"" + installer +
+ "\" --elevate");
+ // create temp lib directory
+ File temp = File.createTempFile("PCTB-lib",null);
+ temp.delete();
+ temp.mkdir();
+ File elevate = new File(temp, "elevate.cmd");
+ OutputStream out = new FileOutputStream(elevate);
+ InputStream in = getClass().getResourceAsStream("/lib/elevate.cmd");
+ Updater.copyFile(in, out);
+
+ elevate = new File(temp, "elevate.vbs");
+ out = new FileOutputStream(elevate);
+ in = getClass().getResourceAsStream("/lib/elevate.vbs");
+ Updater.copyFile(in, out);
+
+ pb.directory(temp);
+ Process p = pb.start();
+ } catch(Exception e) {
+ e.printStackTrace();
+ }
+ System.exit(0);
+ } else {
+ JOptionPane.showMessageDialog(null,"Please run this installer while logged in as an Administrator.");
+ System.exit(0);
+ }
+ }
+ }
+ }
+
+ /**
+ * Create the installer GUI
+ */
+ public Installer(String[] args) {
+ super("PCTB Installer");
+
+ Updater.getUpdater().checkAndUpdate(null, "http://tedpearson.com/market/version",
+ "the PCTB Uploader client", VERSION, true,
+ getClass().getProtectionDomain().getCodeSource().getLocation().getPath());
+
+ // gui: simple window with status area and progress bar
+ checkPermission(args);
+ label = new JLabel("Ready to install!");
+ add(label,BorderLayout.NORTH);
+ progress = new JProgressBar();
+ progress.setBorder(new EmptyBorder(10,0,10,0));
+ add(progress,BorderLayout.CENTER);
+ String buttonText = "Install";
+ install = new JButton(buttonText);
+ JPanel buttons = new JPanel();
+ add(buttons,BorderLayout.SOUTH);
+ install.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent e) {
+ if(installed) {
+ System.exit(0);
+ }
+ try {
+ install.setEnabled(false);
+ uninstall.setEnabled(false);
+ install();
+ } catch(IOException err) {
+ err.printStackTrace();
+ JOptionPane.showMessageDialog(Installer.this, "Error during installation.");
+ setButtonStatus(false,false);
+ label.setText("Install failed!");
+ }
+ }
+ });
+ uninstall = new JButton("Uninstall");
+ buttons.add(uninstall);
+ buttons.add(install);
+ uninstall.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent e) {
+ if(uninstalled) {
+ System.exit(0);
+ }
+ try {
+ install.setEnabled(false);
+ uninstall.setEnabled(false);
+ uninstall();
+ } catch(IOException err) {
+ err.printStackTrace();
+ JOptionPane.showMessageDialog(Installer.this, "Error during installation.");
+ setButtonStatus(false,false);
+ label.setText("Uninstall failed!");
+ }
+ }
+ });
+ getRootPane().setBorder(new EmptyBorder(10,10,10,10));
+ getRootPane().setDefaultButton(install);
+ pack();
+ setSize(300,getHeight());
+ setLocationRelativeTo(null);
+ setDefaultCloseOperation(EXIT_ON_CLOSE);
+ setVisible(true);
+ }
+
+ /**
+ * Uninstalls the client. Throws an IOException ir errors occur.
+ * (removes the PCTB class from assistive tech, deletes the jar)
+ */
+ private void uninstall() throws IOException {
+ label.setText("Uninstalling...");
+ progress.setIndeterminate(true);
+ // remove from assistive tech
+ File java_home = getJavaHome();
+ File a11y = new File(java_home,"lib/accessibility.properties");
+ if(a11y.exists()) {
+ Properties p = new Properties();
+ p.load(new FileInputStream(a11y));
+ String tech = p.getProperty("assistive_technologies");
+ tech = tech.replace("com.tedpearson.ypp.market.MarketUploader", "");
+ p.setProperty("assistive_technologies", tech);
+ p.store(new FileOutputStream(a11y),"Last Modified by PCTB-Installer");
+ }
+ // remove jar
+ File jar = new File(java_home, "lib/ext/PCTB-Uploader.jar");
+ jar.delete();
+ setButtonStatus(false,true);
+ }
+
+ /**
+ * Utility method to find the Java Home folder that runs YPP. On Windows, it could be
+ * inside the YPP folder.
+ */
+ private File getJavaHome() {
+ File java_home = new File(home);
+ if(os.contains("Windows")) {
+ File defaultLocation = null;
+ // check for javavm inside YPP folder, otherwise default location
+ if(os.contains("Vista")) {
+ String user = System.getProperty("user.name");
+ defaultLocation = new File("C:\\Users\\" + user + "\\AppData\\Roaming\\Three Rings Design\\Puzzle Pirates\\");
+ } else if(os.contains("XP")) {
+ defaultLocation = new File("C:\\Program Files\\Three Rings Design\\Puzzle Pirates\\");
+ }
+ if(defaultLocation != null && defaultLocation.exists()) {
+ File java_vm = new File(defaultLocation, "java_vm");
+ if(java_vm.exists()) {
+ // this is where we want to install instead
+ java_home = new File(defaultLocation, "java_vm");
+ }
+ }
+ }
+ return java_home;
+ }
+
+ /**
+ * Installs the client.
+ */
+ private void install() throws IOException {
+ label.setText("Installing...");
+ progress.setIndeterminate(true);
+ File java_home = getJavaHome();
+ File controlPanel = new File(user_home);
+ JFileChooser chooser = new JFileChooser(controlPanel);
+ chooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
+ chooser.setDialogTitle("Choose location for Control Panel");
+ chooser.setApproveButtonText("Install Control Panel here");
+ int state = chooser.showOpenDialog(this);
+ if(state == JFileChooser.APPROVE_OPTION) {
+ controlPanel = chooser.getSelectedFile();
+ } else {
+ setButtonStatus(false,false);
+ label.setText("Install failed!");
+ return;
+ }
+ InputStream in = getClass().getResourceAsStream("/PCTB-ControlPanel.jar");
+ File newFile = new File(controlPanel, "PCTB-ControlPanel.jar");
+ newFile.createNewFile();
+ OutputStream out = new FileOutputStream(newFile);
+ Updater.copyFile(in, out);
+ String search = "assistive_technologies";
+ String value = "com.tedpearson.ypp.market.MarketUploader";
+ File a11y = new File(java_home,"lib/accessibility.properties");
+ boolean skipA11y = false;
+ Properties p = new Properties();
+ if(a11y.exists()) {
+ // if already contains our modification, ignore
+ // else add our modification
+ p.load(new FileInputStream(a11y));
+ String tech = p.getProperty(search);
+ if(tech == null || tech.trim().equals("")) {
+ // add it!
+ p.setProperty(search, value);
+ p.store(new FileOutputStream(a11y),"Last Modified by PCTB-Installer");
+ } else if(!tech.contains(value)) {
+ p.setProperty(search, tech+","+value);
+ p.store(new FileOutputStream(a11y),"Last Modified by PCTB-Installer");
+ }
+ } else {
+ // create file with our modification
+ a11y.createNewFile();
+ p.setProperty(search, value);
+ p.store(new FileOutputStream(a11y),"Last Modified by PCTB-Installer");
+ }
+
+ // install program
+ // copy jar from resource to new file in ext
+ //String installer = getClass().getProtectionDomain().getCodeSource().getLocation()
+ // .getPath().replaceAll("%20"," ");
+ //new FileInputStream(installer);
+ in = getClass().getResourceAsStream("/PCTB-Uploader.jar");
+ newFile = new File(java_home, "lib/ext/PCTB-Uploader.jar");
+ newFile.createNewFile();
+ out = new FileOutputStream(newFile);
+ Updater.copyFile(in, out);
+ JOptionPane.showMessageDialog(this, "Install successful!\n\nWhen you open a new YPP client, you'll see\n" +
+ "the upload client window alongside YPP.\n\n" +
+ "To stop the window from appearing, use\n" +
+ "the Control Panel to disable it, or uninstall.", "Success!", JOptionPane.INFORMATION_MESSAGE);
+ setButtonStatus(true,false);
+ }
+
+ /**
+ * Cleanup after an install, uninstall, or error. Buttons, statuses, and such
+ */
+ private void setButtonStatus(boolean installQ, boolean uninstallQ) {
+ progress.setIndeterminate(false);
+ progress.setValue(100);
+ install.setEnabled(true);
+ uninstall.setEnabled(true);
+ String q = "Quit";
+ if(installQ) {
+ install.setText(q);
+ installed = true;
+ label.setText("Install complete!");
+ } else {
+ install.setText("Install");
+ installed = false;
+ }
+
+ if(uninstallQ) {
+ uninstall.setText(q);
+ uninstalled = true;
+ label.setText("Uninstall successful.");
+ } else {
+ uninstall.setText("Uninstall");
+ uninstalled = false;
+ }
+ }
+}
\ No newline at end of file
--- /dev/null
+package com.tedpearson.ypp.market;
+
+import java.awt.*;
+import java.awt.event.*;
+
+import javax.accessibility.*;
+import javax.swing.*;
+
+import com.sun.java.accessibility.util.*;
+
+import java.util.*;
+import java.io.*;
+import java.util.*;
+import java.net.URL;
+import org.w3c.dom.*;
+import javax.xml.parsers.DocumentBuilderFactory;
+import org.xml.sax.InputSource;
+import java.util.zip.GZIPOutputStream;
+import com.myjavatools.web.ClientHttpRequest;
+import java.util.regex.*;
+import java.util.prefs.Preferences;
+import java.beans.*;
+import com.tedpearson.util.update.*;
+
+/*
+ TODO:
+ allow adding new islands
+ allow adding new oceans
+*/
+
+/**
+* MarketUploader is a class that handles the uploading of market data from
+* Yohoho! Puzzle Pirates. Currently, it must be launched in the save Java
+* Virtual Machine as YPP. This is handled by a sister "helper" class,
+* {@link MarketUploaderRunner}.
+* <p>
+* MarketUploader initializes after the main YPP window has initialized. It
+* provides a simple window with a "Capture Market Data" button displayed.
+* Upon clicking this button, a progress dialog is displayed, and the data
+* is processed and submitted to the Pirate Commodities Trader with Bleach (PCTB)
+* web server. If any errors occur, an error dialog is shown, and processing
+* returns, the button becoming re-enabled.
+*
+* @see MarketUploaderRunner
+*/
+public class MarketUploader implements TopLevelWindowListener, GUIInitializedListener {
+ private JFrame frame = null;
+ private Window window = null;
+ private JButton findMarket = null;
+
+ private final static String PCTB_LIVE_HOST_URL = "http://pctb.crabdance.com/";
+ private final static String PCTB_TEST_HOST_URL = "http://pctb.ilk.org/";
+ private String PCTB_HOST_URL;
+
+ // Yarrg protocol parameters
+ private final static String YARRG_CLIENTNAME = "jpctb greenend";
+ private final static String YARRG_CLIENTVERSION = "0.1";
+ private final static String YARRG_CLIENTFIXES = "";
+ private final static String YARRG_LIVE_URL = "http://upload.yarrg.chiark.net/commod-update-receiver";
+ private final static String YARRG_TEST_URL = "http://upload.yarrg.chiark.net/test/commod-update-receiver";
+ private String YARRG_URL;
+
+ private boolean uploadToYarrg;
+ private boolean uploadToPCTB;
+
+ private String islandName = null;
+ private String oceanName = null;
+ private java.util.concurrent.CountDownLatch latch = null;
+
+ private AccessibleContext sidePanel;
+ private HashMap<String,Integer> commodMap;
+ private HashMap<String,String> islandNumbers = new HashMap<String,String>();
+ {
+ String[] nums = new String[]
+ {"","Viridian","Midnight","Hunter","Cobalt","Sage","Ice","Malachite","Crimson","Opal"};
+ for(int i=1;i<nums.length;i++) {
+ islandNumbers.put(nums[i],""+i);
+ }
+ }
+ private PropertyChangeListener changeListener = new PropertyChangeListener() {
+ public void propertyChange(PropertyChangeEvent e) {
+ if(e.getNewValue() != null &&
+ e.getPropertyName().equals(AccessibleContext.ACCESSIBLE_CHILD_PROPERTY)) {
+ Accessible islandInfo = descendNodes(window,new int[] {0,1,0,0,2,2,0,0,0,0,1,2});;
+ String text = islandInfo.getAccessibleContext().getAccessibleText().getAtIndex(AccessibleText.SENTENCE,0);
+ int index = text.indexOf(":");
+ String name = text.substring(0,index);
+ islandName = name;
+ //System.out.println(islandName);
+ sidePanel.removePropertyChangeListener(this);
+ latch.countDown();
+ }
+ }
+ };
+
+ /**
+ * An abstract market offer, entailing a commodity being bought or sold by
+ * a shoppe, for a certain price in a certain quantity. Not instantiable.
+ *
+ * @see Buy
+ * @see Sell
+ */
+ abstract class Offer {
+ public int commodity, price, quantity, shoppe;
+ /**
+ * Create an offer from <code>record</code>, determining the shoppe Id from
+ * <code>stallMap</code> and the commodity Id from <code>commodMap</code>.
+ * <code>priceIndex</code> should be the index of the price in the record
+ * (the quantity will be <code>priceIndex + 1</code>).
+ *
+ * @param record the record with data to create the offer from
+ * @param stallMap a map containing the ids of the various stalls
+ * @param commodMap a map containing the ids of the various commodities
+ * @param priceIndex the index of the price in the record
+ */
+ public Offer(ArrayList<String> record, LinkedHashMap<String,Integer> stallMap, HashMap<String,Integer> commodMap,
+ int priceIndex) {
+ Integer commodId = commodMap.get(record.get(0));
+ if(commodId == null) {
+ throw new IllegalArgumentException();
+ }
+ commodity = commodId.intValue();
+ price = Integer.parseInt(record.get(priceIndex));
+ String qty = record.get(priceIndex+1);
+ if(qty.equals(">1000")) {
+ quantity = 1001;
+ } else {
+ quantity = Integer.parseInt(record.get(priceIndex+1));
+ }
+ shoppe = stallMap.get(record.get(1)).intValue();
+ }
+
+ /**
+ * Returns a human-readable version of this offer, useful for debugging
+ *
+ * @return human-readable offer
+ */
+ public String toString() {
+ return "[C:" + commodity + ",$" + price + ",Q:" + quantity + ",S:" + shoppe + "]";
+ }
+ }
+
+ /**
+ * An offer from a shoppe or stall to buy a certain quantity of a commodity
+ * for a certain price. If placed in an ordered Set, sorts by commodity index ascending,
+ * then by buy price descending, and finally by stall id ascending.
+ */
+ class Buy extends Offer implements Comparable<Buy> {
+ /**
+ * Creates a new <code>Buy</code> offer from the given <code>record</code>
+ * using the other parameters to determine stall id and commodity id of the offer.
+ *
+ * @param record the record with data to create the offer from
+ * @param stallMap a map containing the ids of the various stalls
+ * @param commodMap a map containing the ids of the various commodities
+ */
+ public Buy(ArrayList<String> record, LinkedHashMap<String,Integer> stallMap, HashMap<String,Integer> commodMap) {
+ super(record,stallMap,commodMap,2);
+ }
+
+ /**
+ * Sorts by commodity index ascending, then price descending, then stall id ascending.
+ */
+ public int compareTo(Buy buy) {
+ // organize by: commodity index, price, stall index
+ if(commodity == buy.commodity) {
+ // organize by price, then by stall index
+ if(price == buy.price) {
+ // organize by stall index
+ return shoppe>buy.shoppe ? 1 : -1;
+ } else if(price > buy.price) {
+ return -1;
+ } else {
+ return 1;
+ }
+ } else if(commodity > buy.commodity) {
+ return 1;
+ } else {
+ return -1;
+ }
+ }
+ }
+
+ /**
+ * An offer from a shoppe or stall to sell a certain quantity of a commodity
+ * for a certain price. If placed in an ordered Set, sorts by commodity index ascending,
+ * then by sell price ascending, and finally by stall id ascending.
+ */
+ class Sell extends Offer implements Comparable<Sell> {
+ /**
+ * Creates a new <code>Sell</code> offer from the given <code>record</code>
+ * using the other parameters to determine stall id and commodity id of the offer.
+ *
+ * @param record the record with data to create the offer from
+ * @param stallMap a map containing the ids of the various stalls
+ * @param commodMap a map containing the ids of the various commodities
+ */
+ public Sell(ArrayList<String> record, LinkedHashMap<String,Integer> stallMap, HashMap<String,Integer> commodMap) {
+ super(record,stallMap,commodMap,4);
+ }
+
+ /**
+ * Sorts by commodity index ascending, then price ascending, then stall id ascending.
+ */
+ public int compareTo(Sell sell) {
+ // organize by: commodity index, price, stall index
+ if(commodity == sell.commodity) {
+ // organize by price, then by stall index
+ if(price == sell.price) {
+ // organize by stall index
+ return shoppe>sell.shoppe ? 1 : -1;
+ } else if(price > sell.price) {
+ return 1;
+ } else {
+ return -1;
+ }
+ } else if(commodity > sell.commodity) {
+ return 1;
+ } else {
+ return -1;
+ }
+ }
+ }
+
+ /**
+ * Entry point. Remove modified files and replace with backups.
+ * Register the jar file we are running from to be deleted upon quit.
+ * Finally, conditionally set up the GUI.
+ */
+ public MarketUploader() {
+ // check if we've been turned off in the control panel
+ Preferences prefs = Preferences.userNodeForPackage(getClass());
+ boolean launch = prefs.getBoolean("launchAtStartup", true);
+ if(!launch) {
+ return;
+ }
+
+ if (prefs.getBoolean("useLiveServers", false)) {
+ YARRG_URL = YARRG_LIVE_URL;
+ PCTB_HOST_URL = PCTB_LIVE_HOST_URL;
+ } else {
+ YARRG_URL = YARRG_TEST_URL;
+ PCTB_HOST_URL = PCTB_TEST_HOST_URL;
+ }
+
+ uploadToYarrg=prefs.getBoolean("uploadToYarrg", true);
+ uploadToPCTB=prefs.getBoolean("uploadToPCTB", true);
+
+ EventQueueMonitor.addTopLevelWindowListener(this);
+ if (EventQueueMonitor.isGUIInitialized()) {
+ createGUI();
+ } else {
+ EventQueueMonitor.addGUIInitializedListener(this);
+ }
+ }
+
+ /**
+ * Set up the GUI, with its window and one-button interface. Only initialize
+ * if we're running alongside a Window named "Puzzle Pirates" though.
+ */
+ private void createGUI() {
+ if (frame != null && window != null) {
+ if (window.getAccessibleContext().getAccessibleName().equals("Puzzle Pirates")) frame.setVisible(true);
+ return;
+ }
+ frame = new JFrame("MarketUploader");
+ frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
+ frame.getContentPane().setLayout(new FlowLayout());
+ //frame.setPreferredSize(new Dimension(200, 60));
+
+ findMarket = new JButton("Upload Market Data");
+ findMarket.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent e) {
+ findMarket.setEnabled(false);
+ new Thread() {
+ public void run() {
+ try {
+ runPCTB();
+ } catch(Exception e) {
+ error(e.toString());
+ e.printStackTrace();
+ } finally {
+ if(sidePanel != null) {
+ // remove it if it's still attached
+ sidePanel.removePropertyChangeListener(changeListener);
+ }
+ }
+ //findMarketTable();
+ findMarket.setEnabled(true);
+ }
+ }.start();
+ }
+ });
+ frame.add(findMarket);
+ frame.pack();
+ }
+
+ /**
+ * Finds the island name from the /who tab, sets global islandName variable
+ */
+ private void getIsland() {
+
+ // If the league tracker is there, we can skip the faff
+ // and ask for its tooltip, since we're on a boat
+
+ Accessible leagueTracker = descendNodes(window,new int[] {0,1,0,0,2,1,1,1});
+ try {
+ islandName = ((JLabel)leagueTracker).getToolTipText();
+ } catch (NullPointerException e) {
+
+ // evidently we're actually on an island
+
+ islandName = null;
+ AccessibleContext chatArea = descendNodes(window,new int[] {0,1,0,0,0,2,0,0,2}).getAccessibleContext();
+ // attach the property change listener to the outer sunshine panel if the "ahoy" tab
+ // is not active, otherwise attach it to the scroll panel in the "ahoy" tab.
+ if(!"com.threerings.piracy.client.AttentionListPanel".
+ equals(descendNodes(window,new int[] {0,1,0,0,2,2,0}).getClass().getCanonicalName())) {
+ sidePanel = descendNodes(window,new int[] {0,1,0,0,2,2}).getAccessibleContext();
+ } else {
+ sidePanel = descendNodes(window,new int[] {0,1,0,0,2,2,0,0,0}).getAccessibleContext();
+ }
+ sidePanel.addPropertyChangeListener(changeListener);
+ latch = new java.util.concurrent.CountDownLatch(1);
+ // make the Players Online ("/who") panel appear
+ AccessibleEditableText chat = chatArea.getAccessibleEditableText();
+ chat.setTextContents("/w");
+ int c = chatArea.getAccessibleAction().getAccessibleActionCount();
+ for(int i=0;i<c;i++) {
+ if("notify-field-accept".equals(chatArea.getAccessibleAction().getAccessibleActionDescription(i))) {
+ chatArea.getAccessibleAction().doAccessibleAction(i);
+ }
+ }
+ }
+ // if we don't find the island name, hopefully the server will
+ }
+
+ /**
+ * Find the ocean name from the window title, and set global oceanName variable
+ */
+ private void getOcean() {
+ oceanName = null;
+ AccessibleContext topwindow = window.getAccessibleContext();
+ oceanName = topwindow.getAccessibleName().replaceAll(".*on the (\\w+) ocean", "$1");
+ }
+
+
+ /**
+ * Shows a dialog with the error <code>msg</code>.
+ *
+ * @param msg a String describing the error that occured.
+ */
+ private void error(String msg) {
+ JOptionPane.showMessageDialog(frame,msg,"Error",JOptionPane.ERROR_MESSAGE);
+ }
+
+ /**
+ * Run the data collection process, and upload the results. This is the method
+ * that calls most of the other worker methods for the process. If an error occurs,
+ * the method will call the error method and return early, freeing up the button
+ * to be clicked again.
+ *
+ * @exception Exception if an error we didn't expect occured
+ */
+ private void runPCTB() throws Exception {
+ String yarrgts = "";
+ ProgressMonitor pm = new ProgressMonitor(frame,"Processing Market Data","Getting table data",0,100);
+ pm.setMillisToDecideToPopup(0);
+ pm.setMillisToPopup(0);
+
+ if (uploadToYarrg) {
+ yarrgts = getYarrgTimestamp();
+ }
+
+ AccessibleTable t = findMarketTable();
+ if(t == null) {
+ error("Market table not found! Please open the Buy/Sell Commodities interface.");
+ return;
+ }
+ if(t.getAccessibleRowCount() == 0) {
+ error("No data found, please wait for the table to have data first!");
+ return;
+ }
+ if(!isDisplayAll()) {
+ error("Please select \"All\" from the Display: popup menu.");
+ return;
+ }
+
+ getIsland();
+ getOcean();
+
+ latch.await(2, java.util.concurrent.TimeUnit.SECONDS);
+
+ ArrayList<ArrayList<String>> data = getData(t);
+
+ if (uploadToYarrg) {
+ pm.setNote("Preparing data for Yarrg");
+ pm.setProgress(10);
+
+ StringBuilder yarrgsb = new StringBuilder();
+ String yarrgdata; // string containing what we'll feed to yarrg
+
+ for (ArrayList<String> row : data) {
+ if (row.size() > 6) {
+ row.remove(6);
+ }
+ for (String rowitem : row) {
+ yarrgsb.append(rowitem != null ? rowitem : "");
+ yarrgsb.append("\t");
+ }
+ yarrgsb.setLength(yarrgsb.length()-1); // chop
+ yarrgsb.append("\n");
+ }
+
+ yarrgdata = yarrgsb.toString();
+
+ pm.setNote("Uploading to Yarrg");
+
+ if (islandName != null) {
+ runYarrg(yarrgts, oceanName, islandName, yarrgdata);
+ } else {
+ System.out.println("Couldn't upload to Yarrg - no island name found");
+ }
+ }
+
+ pm.setNote("Getting stall names");
+ pm.setProgress(20);
+ if(pm.isCanceled()) {
+ return;
+ }
+ TreeSet<Offer> buys = new TreeSet<Offer>();
+ TreeSet<Offer> sells = new TreeSet<Offer>();
+ LinkedHashMap<String,Integer> stallMap = getStallMap(data);
+ pm.setProgress(40);
+ pm.setNote("Sorting offers");
+ if(pm.isCanceled()) {
+ return;
+ }
+ // get commod map
+
+ HashMap<String,Integer> commodMap = getCommodMap();
+ if(commodMap == null) {
+ return;
+ }
+ int[] offerCount = getBuySellMaps(data,buys,sells,stallMap,commodMap);
+ //println(buys.toString());
+ //System.out.println(sells);
+ //System.out.println("\n\n\n"+buys);
+
+ if (uploadToPCTB) {
+ ByteArrayOutputStream outStream = new ByteArrayOutputStream();
+ pm.setProgress(60);
+ pm.setNote("Sending data");
+ if(pm.isCanceled()) {
+ return;
+ }
+ GZIPOutputStream out = new GZIPOutputStream(outStream);
+ //FileOutputStream out = new FileOutputStream(new File("output.text"));
+ DataOutputStream dos = new DataOutputStream(out);
+ dos.writeBytes("005\n");
+ dos.writeBytes(stallMap.size()+"\n");
+ dos.writeBytes(getAbbrevStallList(stallMap));
+ writeBuySellOffers(buys,sells,offerCount,out);
+ out.finish();
+ InputStream in = sendInitialData(new ByteArrayInputStream(outStream.toByteArray()));
+ pm.setProgress(80);
+ if(pm.isCanceled()) {
+ return;
+ }
+ pm.setNote("Waiting for PCTB...");
+ finishUpload(in);
+ }
+ pm.setProgress(100);
+ }
+
+ /**
+ * Get the offer data out of the table and cache it in an <code>ArrayList</code>.
+ *
+ * @param table the <code>AccessibleTable</code> containing the market data
+ * @return an array of record arrays, each representing a row of the table
+ */
+ private ArrayList<ArrayList<String>> getData(AccessibleTable table) {
+ ArrayList<ArrayList<String>> data = new ArrayList<ArrayList<String>>();
+ for (int i = 0; i < table.getAccessibleRowCount(); i++) {
+ ArrayList<String> row = new ArrayList<String>();
+ for (int j = 0; j < table.getAccessibleColumnCount(); j++) {
+ row.add(table.getAccessibleAt(i, j).getAccessibleContext().getAccessibleName());
+ }
+ data.add(row);
+ }
+ return data;
+ }
+
+ /**
+ * @return the table containing market data if it exists, otherwise <code>null</code>
+ */
+ public AccessibleTable findMarketTable() {
+ Accessible node1 = window;
+ Accessible node = descendNodes(node1,new int[] {0,1,0,0,0,0,1,0,0,1,0,0}); // commod market
+ // commod market: {0,1,0,0,0,0,1,0,0,1,0} {0,1,0,0,0,0,1,0,1,0,0,1,0,0})
+ //System.out.println(node);
+ if (!(node instanceof JTable)) {
+ node = descendNodes(node1,new int[] {0,1,0,0,0,0,1,0,1,0,0,1,0,0}); // commod market
+ }
+ if (!(node instanceof JTable)) return null;
+ AccessibleTable table = node.getAccessibleContext().getAccessibleTable();
+ //System.out.println(table);
+ return table;
+ }
+
+ /**
+ * Utility method to descend through several levels of Accessible children
+ * at once.
+ *
+ * @param parent the node on which to start the descent
+ * @param path an array of ints, each int being the index of the next
+ * accessible child to descend.
+ * @return the <code>Accessible</code> reached by following the descent path,
+ * or <code>null</code> if the desired path was invalid.
+ */
+ private Accessible descendNodes(Accessible parent, int[] path) {
+ for(int i=0;i<path.length;i++) {
+ if (null == (parent = descend(parent, path[i]))) return null;
+ // System.out.println(parent.getClass());
+ }
+ return parent;
+ }
+
+ /**
+ * Descends one level to the specified child of the parent <code>Accessible</code> "node".
+ *
+ * @param parent the node with children
+ * @param childNum the index of the child of <code>parent</code> to return
+ * @return the <code>childNum</code> child of <code>parent</code> or <code>null</code>
+ * if the child is not found.
+ */
+ private Accessible descend(Accessible parent, int childNum) {
+ if (childNum >= parent.getAccessibleContext().getAccessibleChildrenCount()) return null;
+ return parent.getAccessibleContext().getAccessibleChild(childNum);
+ }
+
+ public static void main(String[] args) {
+ new MarketUploader();
+ }
+
+ /**
+ * Set the global window variable after the YPP window is created,
+ * remove the top level window listener, and start the GUI
+ */
+ public void topLevelWindowCreated(Window w) {
+ window = w;
+ EventQueueMonitor.removeTopLevelWindowListener(this);
+ createGUI();
+ }
+
+ /**
+ * Returns true if the "Display:" menu on the commodities interface in YPP is set to "All"
+ *
+ * @return <code>true</code> if all commodities are displayed, otherwise <code>false</code>
+ */
+ private boolean isDisplayAll() {
+ Accessible button = descendNodes(window,new int[] {0,1,0,0,0,0,1,0,0,0,1});
+ if(!(button instanceof JButton)) {
+ button = descendNodes(window,new int[] {0,1,0,0,0,0,1,0,1,0,0,0,1});
+ }
+ String display = button.getAccessibleContext().getAccessibleName();
+ if(!display.equals("All")) {
+ return false;
+ }
+ return true;
+ }
+
+ public void topLevelWindowDestroyed(Window w) {}
+
+ public void guiInitialized() {
+ createGUI();
+ }
+
+ /**
+ * Gets the list of commodities and their associated commodity ids.
+ * On the first run, the data is downloaded from the PCTB server.
+ * After the first run, the data is cached using <code>Preferences</code>.
+ * <p>
+ * Potential issues: When more commodities are added to the server, this
+ * program will currently break unless the user deletes the preferences
+ * file or we give them a new release with a slighly different storage
+ * location for the data.
+ *
+ * @return a map where the key is the commodity and the value is the commodity id.
+ */
+ private HashMap<String,Integer> getCommodMap() {
+ if(commodMap != null) {
+ return commodMap;
+ }
+ HashMap<String,Integer> map = new HashMap<String,Integer>();
+ Preferences prefs = Preferences.userNodeForPackage(getClass());
+ String xml;
+ try {
+ URL host = new URL(PCTB_HOST_URL + "commodmap.php");
+ BufferedReader br = new BufferedReader(new InputStreamReader(host.openStream()));
+ StringBuilder sb = new StringBuilder();
+ String str;
+ while((str = br.readLine()) != null) {
+ sb.append(str);
+ }
+ int first = sb.indexOf("<pre>") + 5;
+ int last = sb.indexOf("</body>");
+ xml = sb.substring(first,last);
+ //System.out.println(xml);
+ Reader reader = new CharArrayReader(xml.toCharArray());
+ Document d = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(new InputSource(reader));
+ NodeList maps = d.getElementsByTagName("c");
+ for(int i=0;i<maps.getLength();i++) {
+ NodeList content = maps.item(i).getChildNodes();
+ Integer num = Integer.parseInt(content.item(1).getTextContent());
+ map.put(content.item(0).getTextContent(),num);
+ }
+ } catch(Exception e) {
+ e.printStackTrace();
+ error("Unable to load Commodity list from server!");
+ return null;
+ }
+ commodMap = map;
+ return map;
+ }
+
+ /**
+ * Given the list of offers, this method will find all the unique stall names
+ * and return them in a <code>LinkedHashMap</code> where the key is the stall name
+ * and the value is the generated stall id (position in the list).
+ * <p>
+ * The reason this method returns a LinkedHashMap instead of a simple HashMap is the need
+ * for iterating over the stall names in insertion order for output to the server.
+ *
+ * @param offers the list of records from the commodity buy/sell interface
+ * @return an iterable ordered map of the stall names and generated stall ids
+ */
+ private LinkedHashMap<String,Integer> getStallMap(ArrayList<ArrayList<String>> offers) {
+ int count = 0;
+ LinkedHashMap<String,Integer> map = new LinkedHashMap<String,Integer>();
+ for(ArrayList<String> offer : offers) {
+ String shop = offer.get(1);
+ if(!map.containsKey(shop)) {
+ count++;
+ map.put(shop,count);
+ }
+ }
+ return map;
+ }
+
+ /**
+ * Gets a sorted list of Buys and Sells from the list of records. <code>buys</code> and <code>sells</code>
+ * should be pre-initialized and passed into the method to receive the data.
+ * Returns a 2-length int array with the number of buys and sells found.
+ *
+ * @param offers the data found from the market table in-game
+ * @param buys an empty initialized <code>TreeSet<Offer></code> to
+ * hold the Buy offers.
+ * @param sells an empty initialized <code>TreeSet<Offer></code> to
+ * hold the Sell offers.
+ * @param stalls the map of stalls to their ids
+ * @param commodMap the map of commodities to their ids
+ * @return a 2-length int[] array containing the number of buys and sells, respectively
+ */
+ private int[] getBuySellMaps(ArrayList<ArrayList<String>> offers, TreeSet<Offer> buys,
+ TreeSet<Offer> sells, LinkedHashMap<String,Integer> stalls, HashMap<String,Integer> commodMap) {
+ int[] buySellCount = new int[2];
+ for(ArrayList<String> offer : offers) {
+ try {
+ if(offer.get(2) != null) {
+ buys.add(new Buy(offer,stalls,commodMap));
+ buySellCount[0]++;
+ }
+ if(offer.get(4) != null) {
+ sells.add(new Sell(offer,stalls,commodMap));
+ buySellCount[1]++;
+ }
+ } catch(IllegalArgumentException e) {
+ // System.err.println("Error: Unsupported Commodity \"" + offer.get(0) + "\"");
+ }
+ }
+ return buySellCount;
+ }
+
+ /**
+ * Prepares the list of stalls for writing to the output stream.
+ * The <code>String</code> returned by this method is ready to be written
+ * directly to the stream.
+ * <p>
+ * All shoppe names are left as they are. Stall names are abbreviated just before the
+ * apostrophe in the possessive, with an "^" and a letter matching the stall's type
+ * appended. Example: "Burninator's Ironworking Stall" would become "Burninator^I".
+ *
+ * @param stallMap the map of stalls and stall ids in an iterable order
+ * @return a <code>String</code> containing the list of stalls in format ready
+ * to be written to the output stream.
+ */
+ private String getAbbrevStallList(LinkedHashMap<String,Integer> stallMap) {
+ // set up some mapping
+ HashMap<String,String> types = new HashMap<String,String>();
+ types.put("Apothecary Stall", "A");
+ types.put("Distilling Stall", "D");
+ types.put("Furnishing Stall", "F");
+ types.put("Ironworking Stall", "I");
+ types.put("Shipbuilding Stall", "S");
+ types.put("Tailoring Stall", "T");
+ types.put("Weaving Stall", "W");
+
+ StringBuilder sb = new StringBuilder();
+ for(String name : stallMap.keySet()) {
+ int index = name.indexOf("'s");
+ String finalName = name;
+ String type = null;
+ if (index > 0) {
+ finalName = name.substring(0,index);
+ if(index + 2 < name.length()) {
+ String end = name.substring(index+2,name.length()).trim();
+ type = types.get(end);
+ }
+ }
+ if(type==null) {
+ sb.append(name+"\n");
+ } else {
+ sb.append(finalName+"^"+type+"\n");
+ }
+ }
+ return sb.toString();
+ }
+
+ /**
+ * Writes a list of offers in correct format to the output stream.
+ * <p>
+ * The format is thus: (all numbers are 2-byte integers in little-endian format)
+ * (number of offers of this type, aka buy/sell)
+ * (commodity ID) (number of offers for this commodity) [shopID price qty][shopID price qty]...
+ *
+ * @param out the output stream to write the data to
+ * @param offers the offers to write
+ */
+ private void writeOffers(OutputStream out, TreeSet<Offer> offers) throws IOException {
+ ByteArrayOutputStream buffer = new ByteArrayOutputStream();
+ if(offers.size() == 0) {
+ // nothing to write, and "0" has already been written
+ return;
+ }
+ int commodity = offers.first().commodity;
+ int count = 0;
+ for(Offer offer : offers) {
+ if(commodity != offer.commodity) {
+ // write out buffer
+ writeBufferedOffers(out,buffer.toByteArray(),commodity,count);
+ buffer.reset();
+ commodity = offer.commodity;
+ count = 0;
+ }
+ writeLEShort(offer.shoppe,buffer); // stall index
+ writeLEShort(offer.price,buffer); // buy price
+ writeLEShort(offer.quantity,buffer); // buy qty
+ count++;
+ }
+ writeBufferedOffers(out,buffer.toByteArray(),commodity,count);
+ }
+
+ /**
+ * Writes the buffered data to the output strea for one commodity.
+ *
+ * @param out the stream to write to
+ * @param buffer the buffered data to write
+ * @param commodity the commmodity id to write before the buffered data
+ * @param count the number of offers for this commodity to write before the data
+ */
+ private void writeBufferedOffers(OutputStream out, byte[] buffer, int commodity, int count) throws IOException {
+ writeLEShort(commodity,out); // commod index
+ writeLEShort(count,out); // offer count
+ out.write(buffer); // the buffered offers
+ }
+
+ /**
+ * Writes the buy and sell offers to the outputstream by calling other methods.
+ *
+ * @param buys list of Buy offers to write
+ * @param sells list of Sell offers to write
+ * @param offerCount 2-length int array containing the number of buys and sells to write out
+ * @param out the stream to write to
+ */
+ private void writeBuySellOffers(TreeSet<Offer> buys,
+ TreeSet<Offer> sells, int[] offerCount, OutputStream out) throws IOException {
+ // # buy offers
+ writeLEShort(offerCount[0],out);
+ writeOffers(out,buys);
+ // # sell offers
+ writeLEShort(offerCount[1],out);
+ writeOffers(out,sells);
+ }
+
+ /**
+ * Sends the data to the server via multipart-formdata POST,
+ * with the gzipped data as a file upload.
+ *
+ * @param file an InputStream open to the gzipped data we want to send
+ */
+ private InputStream sendInitialData(InputStream file) throws IOException {
+ ClientHttpRequest http = new ClientHttpRequest(PCTB_HOST_URL + "upload.php");
+ http.setParameter("marketdata","marketdata.gz",file,"application/gzip");
+ return http.post();
+ }
+
+ /**
+ * Utility method to write a 2-byte int in little-endian form to an output stream.
+ *
+ * @param num an integer to write
+ * @param out stream to write to
+ */
+ private void writeLEShort(int num, OutputStream out) throws IOException {
+ out.write(num & 0xFF);
+ out.write((num >>> 8) & 0xFF);
+ }
+
+ /**
+ * Reads the response from the server, and selects the correct parameters
+ * which are sent in a GET request to the server asking it to confirm
+ * the upload and accept the data into the database. Notably, the island id
+ * and ocean id are determined, while other parameter such as the filename
+ * are determined from the hidden form fields.
+ *
+ * @param in stream of data from the server to read
+ */
+ private void finishUpload(InputStream in) throws IOException {
+ StringBuilder sb = new StringBuilder();
+ BufferedReader br = new BufferedReader(new InputStreamReader(in));
+ String str;
+ while((str = br.readLine()) != null) {
+ sb.append(str+"\n");
+ }
+ String html = sb.toString();
+ //System.out.println(html);
+ String topIsland = "0", ocean, islandNum, action, forceReload, filename;
+ Matcher m;
+ Pattern whoIsland = Pattern.compile("<option value=\"\\d+\">" + islandName + ", ([^<]+)</ocean>");
+ m = whoIsland.matcher(html);
+ if(m.find()) {
+ // the server agrees with us
+ ocean = islandNumbers.get(m.group(1));
+ } else {
+ // if the server doesn't agree with us:
+ Pattern island = Pattern.compile("<option value=\"(\\d+)\">([^,]+), ([^<]+)</ocean>");
+ m = island.matcher(html);
+ if(!m.find()) {
+ // server doesn't know what island. if we do, let's select it.
+ if(islandName != null && !islandName.equals("")) {
+ // find the island name in the list as many times as it occurs
+ // if more than once, present a dialog
+ // set the ocean, we have the islandname, topIsland = 0
+ Pattern myIsland = Pattern.compile("islands\\[(\\d+)\\]\\[\\d+\\]=new Option\\(\"" + islandName +
+ "\",\\d+");
+ Matcher m1 = myIsland.matcher(html);
+ ArrayList<Integer> myOceanNums = new ArrayList<Integer>();
+ while(m1.find()) {
+ myOceanNums.add(new Integer(m1.group(1)));
+ }
+ if(myOceanNums.size() > 0) {
+ if(myOceanNums.size() > 1) {
+ String[] myOceansList = new String[myOceanNums.size()];
+ int i = 0;
+ for(int myOcean : myOceanNums) {
+ Pattern oceanNumPat = Pattern.compile("<option value=\"\\" + myOcean + "\">([^<]+)</option>");
+ m1 = oceanNumPat.matcher(html);
+ if(m1.find()) {
+ myOceansList[i++] = m1.group(1);
+ }
+ }
+ Object option = JOptionPane.showInputDialog(null,"We found islands named \"" +
+ islandName +"\" on " + myOceansList.length + " oceans:","Choose Ocean",
+ JOptionPane.QUESTION_MESSAGE, null, myOceansList, null);
+ if(option == null) {
+ error("Unable to determine the current island!");
+ return;
+ }
+ ocean = islandNumbers.get(option).toString();
+ } else {
+ ocean = myOceanNums.get(0).toString();
+ }
+ } else {
+ error("Unknown island!");
+ return;
+ }
+ } else {
+ error("Unable to determine island name from the client!");
+ return;
+ }
+ } else {
+ topIsland = m.group(1);
+ islandName = m.group(2);
+ ocean = islandNumbers.get(m.group(3));
+ }
+ }
+ Pattern oceanIslandNum = Pattern.compile("islands\\[" + ocean + "\\]\\[\\d+\\]=new Option\\(\"" + islandName + "\",(\\d+)");
+ m = oceanIslandNum.matcher(html);
+ if(!m.find()) {
+ error("This does not seem to be a valid island! Unable to upload.");
+ return;
+ }
+ islandNum = m.group(1);
+ Pattern params = Pattern.compile("(?s)<input type=\"hidden\" name=\"action\" value=\"([^\"]+)\" />.+?<input type=\"hidden\" name=\"forcereload\" value=\"([^\"]+)\" />.+?<input type=\"hidden\" name=\"filename\" value=\"([^\"]+)\" />");
+ m = params.matcher(html);
+ if(!m.find()) {
+ error("The PCTB server returned unusual data. Maybe you're using an old version of the uploader?");
+ return;
+ }
+ action = m.group(1);
+ forceReload = m.group(2);
+ filename = m.group(3);
+ URL get = new URL(PCTB_HOST_URL + "upload.php?topisland=" + topIsland + "&ocean=" + ocean + "&island="
+ + islandNum + "&action=" + action + "&forcereload=" + forceReload + "&filename=" + filename);
+ // System.out.println(get);
+ BufferedReader br2 = new BufferedReader(new InputStreamReader(get.openStream()));
+ sb = new StringBuilder();
+ while((str = br2.readLine()) != null) {
+ sb.append(str+"\n");
+ }
+ Pattern done = Pattern.compile("Your data has been integrated into the database. Thank you!");
+ m = done.matcher(sb.toString());
+ if(m.find()) {
+ //System.out.println("FILE upload successful!!!");
+ } else {
+ error("Something was wrong with the final upload parameters!");
+ System.err.println(sb.toString());
+ System.err.println(html);
+ }
+ }
+
+ private String getYarrgTimestamp() throws IOException {
+ ClientHttpRequest http = new ClientHttpRequest (YARRG_URL);
+ http.setParameter("clientname", YARRG_CLIENTNAME);
+ http.setParameter("clientversion", YARRG_CLIENTVERSION);
+ http.setParameter("clientfixes", YARRG_CLIENTFIXES);
+ http.setParameter("requesttimestamp", "y");
+ InputStream in = http.post();
+ BufferedReader br = new BufferedReader(new InputStreamReader(in));
+ String tsresult = br.readLine();
+ return tsresult.substring(3, tsresult.length()-1);
+ }
+
+ private void runYarrg(String timestamp, String ocean, String island, String yarrgdata) throws IOException {
+ ByteArrayOutputStream bos = new ByteArrayOutputStream();
+ BufferedOutputStream bufos = new BufferedOutputStream(new GZIPOutputStream(bos));
+ bufos.write(yarrgdata.getBytes() );
+ bufos.close();
+ ByteArrayInputStream file = new ByteArrayInputStream(bos.toByteArray());
+
+ ClientHttpRequest http = new ClientHttpRequest (YARRG_URL);
+ http.setParameter("clientname", YARRG_CLIENTNAME);
+ http.setParameter("clientversion", YARRG_CLIENTVERSION);
+ http.setParameter("clientfixes", YARRG_CLIENTFIXES);
+ http.setParameter("timestamp", timestamp);
+ http.setParameter("ocean", ocean);
+ http.setParameter("island", island);
+ http.setParameter("data", "deduped.tsv.gz", file, "application/octet-stream");
+ InputStream in = http.post();
+ BufferedReader br = new BufferedReader(new InputStreamReader(in));
+ String yarrgresult;
+ while((yarrgresult = br.readLine()) != null) {
+ System.out.println(yarrgresult);
+ }
+ }
+
+}
~yarrgweb / jarrg-ian.git / commitdiff