Git - Openforge

package com.stream_pi.client.connection;

import com.stream_pi.action_api.action.Action;

import com.stream_pi.action_api.action.ActionType;

import com.stream_pi.action_api.action.DisplayTextAlignment;

import com.stream_pi.action_api.action.Location;

import com.stream_pi.action_api.actionproperty.ClientProperties;

import com.stream_pi.action_api.actionproperty.property.Property;

import com.stream_pi.action_api.actionproperty.property.Type;

import com.stream_pi.client.io.Config;

import com.stream_pi.client.info.ClientInfo;

import com.stream_pi.client.profile.ClientProfile;

import com.stream_pi.client.window.ExceptionAndAlertHandler;

import com.stream_pi.client.window.dashboard.actiongridpane.ActionBox;

import com.stream_pi.theme_api.Theme;

import com.stream_pi.util.alert.StreamPiAlertType;

import com.stream_pi.util.comms.Message;

import com.stream_pi.util.exception.MinorException;

import com.stream_pi.util.exception.SevereException;

import com.stream_pi.util.platform.Platform;

import com.stream_pi.util.platform.ReleaseStatus;

import com.stream_pi.util.version.Version;

import javafx.concurrent.Task;

import java.io.*;

import java.net.InetSocketAddress;

import java.net.Socket;

import java.util.ArrayList;

import java.util.concurrent.atomic.AtomicBoolean;

import java.util.logging.Logger;

public class Client extends Thread{

private Socket socket;

//private Logger logger;

private ObjectOutputStream oos;

private ObjectInputStream ois;

private DataOutputStream dos;

private final AtomicBoolean stop = new AtomicBoolean(false);

private DataInputStream dis;

private AtomicBoolean stop = new AtomicBoolean(false);

private final ClientListener clientListener;

private final ExceptionAndAlertHandler exceptionAndAlertHandler;

private ClientListener clientListener;

private final ClientInfo clientInfo;

private ExceptionAndAlertHandler exceptionAndAlertHandler;

private ClientInfo clientInfo;

private final String serverIP;

private final int serverPort;

private String serverIP;

private final Logger logger;

private int serverPort;

private Logger logger;

public Client(String serverIP, int serverPort, ClientListener clientListener, ExceptionAndAlertHandler exceptionAndAlertHandler)

{

this.serverIP = serverIP;

this.serverPort = serverPort;

this.exceptionAndAlertHandler = exceptionAndAlertHandler;

this.clientInfo = ClientInfo.getInstance();

this.clientListener = clientListener;

logger = Logger.getLogger(Client.class.getName());

new Thread(new Task<Void>() {

@Override

protected Void call()

{

try

{

try {

try

{

logger.info("Trying to connect to server at "+serverIP+":"+serverPort);

socket = new Socket();

socket.connect(new InetSocketAddress(serverIP, serverPort), 5000);

clientListener.setConnected(true);

clientListener.updateSettingsConnectDisconnectButton();

logger.info("Connected to "+socket.getRemoteSocketAddress()+" !");

} catch (IOException e) {

}

catch (IOException e)

{

e.printStackTrace();

clientListener.setConnected(false);

clientListener.updateSettingsConnectDisconnectButton();

throw new MinorException("connection Error", "Unable to connect to server. Please check settings and connection and try again.");

}

try

{

dos = new DataOutputStream(socket.getOutputStream());

oos = new ObjectOutputStream(socket.getOutputStream());

dis = new DataInputStream(socket.getInputStream());

ois = new ObjectInputStream(socket.getInputStream());

}

catch (IOException e)

{

logger.severe(e.getMessage());

e.printStackTrace();

throw new MinorException("Unable to set up io Streams to server. Check connection and try again.");

}

start();

} catch (MinorException e)

{

exceptionAndAlertHandler.handleMinorException(e);

}

return null;

}

}).start();

}

public synchronized void exit()

{

if(stop.get())

return;

logger.info("Stopping ...");

try

{

if(socket!=null)

{

disconnect();

}

catch (SevereException e)

{

logger.severe(e.getMessage());

exceptionAndAlertHandler.handleSevereException(e);

e.printStackTrace();

}

public void sendMessage(Message message) throws SevereException

public void writeToStream(String text) throws SevereException

{

/*try

{

logger.debug(text);

dos.writeUTF(text);

dos.flush();

}

catch (IOException e)

{

e.printStackTrace();

throw new SevereException("Unable to write to io Stream!");

}*/

try

{

byte[] txtBytes = text.getBytes();

oos.writeObject(message);

oos.flush();

Thread.sleep(50);

dos.writeUTF("string:: ::");

dos.flush();

dos.writeInt(txtBytes.length);

dos.flush();

write(txtBytes);

dos.flush();

}

catch (IOException | InterruptedException e)

{

e.printStackTrace();

throw new SevereException("Unable to write to io Stream!");

}

public void write(byte[] array) throws SevereException

{

try

{

dos.write(array);

}

catch (IOException e)

{

logger.severe(e.getMessage());

e.printStackTrace();

throw new SevereException("Unable to write to io Stream!");

}

@Override

public void run() {

try

{

while(!stop.get())

{

String msg = "";

try

{

String raw = dis.readUTF();

Message message = (Message) ois.readObject();

System.out.println("AAAAAAAAAAAAAAAAAA : "+raw);

int length = dis.readInt();

String[] precursor = raw.split("::");

String inputType = precursor[0];

String header = message.getHeader();

String secondArg = precursor[1];

logger.info("Message Received. Heading : "+header);

//ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

switch (header)

/*int count;

int chunkSize = 512;

while (length>0)

{

if(chunkSize > length)

case "action_icon" : onActionIconReceived(message);

chunkSize = length;

break;

else

chunkSize = 512;

byte[] buffer = new byte[chunkSize];

case "disconnect" : serverDisconnected(message);

count = dis.read(buffer);

break;

byteArrayOutputStream.write(buffer);

case "get_client_details" : sendClientDetails();

break;

length-=count;

case "get_profiles" : sendProfileNamesToServer();

}*/

break;

/*byte[] buffer = new byte[8192];

case "get_profile_details": sendProfileDetailsToServer(message);

int read;

break;

while((read = dis.read(buffer)) != -1){

System.out.println("READ : "+read);

byteArrayOutputStream.write(buffer, 0, read);

}

case "save_action_details": saveActionDetails(message);

break;

byteArrayOutputStream.close();

case "delete_action": deleteAction(message);

break;

byte[] bArr = byteArrayOutputStream.toByteArray();*/

case "get_themes": sendThemesToServer();

break;

byte[] bArr = new byte[length];

case "save_client_details": saveClientDetails(message);

break;

dis.readFully(bArr);

case "save_client_profile": saveProfileDetails(message);

break;

if(inputType.equals("string"))

case "delete_profile": deleteProfile(message);

{

break;

msg = new String(bArr);

}

else if(inputType.equals("action_icon"))

{

System.out.println("asdsdsxxxxxxxxxxxxxxxxxxxxxxxxxxx");

String[] secondArgSep = secondArg.split("!!");

String profileID = secondArgSep[0];

String actionID = secondArgSep[1];

clientListener.getClientProfiles().getProfileFromID(profileID).saveActionIcon(actionID, bArr);

Action a = clientListener.getClientProfiles().getProfileFromID(profileID).getActionFromID(actionID);

case "action_failed": actionFailed(message);

clientListener.clearActionBox(a.getLocation().getCol(), a.getLocation().getRow());

break;

clientListener.renderAction(profileID, a);

default: logger.warning("Command '"+header+"' does not match records. Make sure client and server versions are equal.");

continue;

}

catch (IOException e)

catch (IOException | ClassNotFoundException e)

{

logger.severe(e.getMessage());

e.printStackTrace();

clientListener.setConnected(false);

clientListener.updateSettingsConnectDisconnectButton();

if(!stop.get())

{

//isDisconnect.set(true); //Prevent running disconnect

throw new MinorException("Accidentally disconnected from Server! (Failed at readUTF)");

}

exit();

return;

}

logger.info("Received text : '"+msg+"'");

String[] sep = msg.split("::");

String command = sep[0];

switch (command)

{

case "disconnect" : serverDisconnected(msg);

break;

case "get_client_details" : sendClientDetails();

break;

case "get_profiles" : sendProfileNamesToServer();

break;

case "get_profile_details": sendProfileDetailsToServer(sep[1]);

break;

case "save_action_details": saveActionDetails(sep);

break;

case "delete_action": deleteAction(sep[1], sep[2]);

break;

case "get_themes": sendThemesToServer();

break;

case "save_client_details": saveClientDetails(sep);

break;

case "save_client_profile": saveProfileDetails(sep);

break;

case "delete_profile": deleteProfile(sep[1]);

break;

case "action_failed": actionFailed(sep[1], sep[2]);

break;

default: logger.warning("Command '"+command+"' does not match records. Make sure client and server versions are equal.");

}

catch (SevereException e)

{

logger.severe(e.getMessage());

e.printStackTrace();

exceptionAndAlertHandler.handleSevereException(e);

}

catch (MinorException e)

{

logger.severe(e.getMessage());

e.printStackTrace();

exceptionAndAlertHandler.handleMinorException(e);

}

private void onActionIconReceived(Message message)

{

String profileID = message.getStringArrValue()[0];

String actionID = message.getStringArrValue()[1];

clientListener.getClientProfiles().getProfileFromID(profileID).saveActionIcon(

actionID,

message.getByteArrValue()

);

Action a = clientListener.getClientProfiles().getProfileFromID(profileID).getActionFromID(actionID);

clientListener.clearActionBox(a.getLocation().getCol(), a.getLocation().getRow());

clientListener.renderAction(profileID, a);

}

//commands

/*public void receiveActionIcon(String[] sep) throws MinorException {

String profileID = sep[1];

String actionID = sep[2];

int bytesToRead = Integer.parseInt(sep[3]);

int port = Integer.parseInt(sep[4]);

try

{

Socket tempSocket = new Socket(socket.getInetAddress(), port);

tempSocket.setReceiveBufferSize(bytesToRead);

tempSocket.setSoTimeout(10000);

DataInputStream dataInputStream = new DataInputStream(tempSocket.getInputStream());

byte[] dataIcon = new byte[bytesToRead];

dataInputStream.read(dataIcon);

clientProfiles.getProfileFromID(profileID).getActionFromID(actionID).setIcon(dataIcon);

dataInputStream.close();

tempSocket.close();

}

catch (IOException e)

{

e.printStackTrace();

throw new MinorException("Unable to Receive icon");

}

}*/

//commands

public void sendIcon(String profileID, String actionID, byte[] icon) throws SevereException

{

try

Message message = new Message("action_icon");

{

message.setStringArrValue(profileID, actionID);

Thread.sleep(50);

message.setByteArrValue(icon);

dos.writeUTF("action_icon::"+profileID+"!!"+actionID+"!!::"+icon.length);

sendMessage(message);

dos.flush();

dos.writeInt(icon.length);

dos.flush();

write(icon);

dos.flush();

}

catch (IOException | InterruptedException e)

{

e.printStackTrace();

throw new SevereException("Unable to write to io Stream!");

}

/*public void sendIcon(String profileID, String actionID, byte[] icon) throws SevereException

{

try

{

ServerSocket tmpServer = new ServerSocket(0);

dos.writeUTF("action_icon::"+

profileID+"::"+

actionID+"::"+

icon.length+"::"+

tmpServer.getLocalPort()+"::");

Socket socket = tmpServer.accept();

socket.setSendBufferSize(icon.length);

DataOutputStream dataOutputStream = new DataOutputStream(socket.getOutputStream());

dataOutputStream.write(icon);

dataOutputStream.close();

tmpServer.close();

}

catch (IOException e)

{

e.printStackTrace();

throw new SevereException(e.getMessage());

}

}*/

public void disconnect() throws SevereException

{

disconnect("");

}

public void disconnect(String message) throws SevereException

{

if(stop.get())

return;

stop.set(true);

logger.info("Sending server disconnect message ...");

writeToStream("disconnect::"+message+"::");

Message m = new Message("disconnect");

m.setStringValue(message);

sendMessage(m);

try

{

if(!socket.isClosed())

socket.close();

clientListener.setConnected(false);

clientListener.updateSettingsConnectDisconnectButton();

}

catch (IOException e)

{

e.printStackTrace();

throw new SevereException("Unable to close socket");

}

public void sendThemesToServer() throws SevereException

{

StringBuilder finalQuery = new StringBuilder("themes::");

Message message = new Message("themes");

String[] arr = new String[clientListener.getThemes().getThemeList().size()*4];

for(Theme theme : clientListener.getThemes().getThemeList())

int x = 0;

for(int i = 0;i<clientListener.getThemes().getThemeList().size();i++)

{

finalQuery.append(theme.getFullName())

Theme theme = clientListener.getThemes().getThemeList().get(i);

.append("__")

.append(theme.getShortName())

arr[x] = theme.getFullName();

.append("__")

arr[x+1] = theme.getShortName();

.append(theme.getAuthor())

arr[x+2] = theme.getAuthor();

.append("__")

arr[x+3] = theme.getVersion().getText();

.append(theme.getVersion().getText())

.append("__::");

x+=4;

}

writeToStream(finalQuery.toString());

message.setStringArrValue(arr);

sendMessage(message);

}

public void sendActionIcon(String clientProfileID, String actionID) throws SevereException

{

System.out.println("sending action icon "+clientProfileID+", "+actionID);

sendIcon(clientProfileID, actionID, clientListener.getClientProfiles().getProfileFromID(clientProfileID).getActionFromID(actionID).getIconAsByteArray());

}

public void serverDisconnected(String message)

public void serverDisconnected(Message message)

{

stop.set(true);

String txt = "Disconnected!";

if(!message.equals("disconnect::::"))

String m = message.getStringValue();

txt = "Message : "+message.split("::")[1];

if(!m.isBlank())

txt = "Message : "+m;

exceptionAndAlertHandler.onAlert("Disconnected from Server", txt, StreamPiAlertType.WARNING);

if(!socket.isClosed()) {

try {

socket.close();

} catch (IOException e) {

e.printStackTrace();

}

clientListener.setConnected(false);

clientListener.updateSettingsConnectDisconnectButton();

}

public void sendClientDetails() throws SevereException

{

Version clientVersion = clientInfo.getVersion();

String clientVersion = clientInfo.getVersion().getText();

ReleaseStatus releaseStatus = clientInfo.getReleaseStatus();

String releaseStatus = clientInfo.getReleaseStatus().toString();

Version clientCommsStandard = clientInfo.getCommsStandardVersion();

String clientCommsStandard = clientInfo.getCommsStandardVersion().getText();

Version clientMinThemeStandard = clientInfo.getMinThemeSupportVersion();

String clientMinThemeStandard = clientInfo.getMinThemeSupportVersion().getText();

String clientNickname = Config.getInstance().getClientNickName();

double screenWidth = Config.getInstance().getStartupWindowWidth();

String screenWidth = Config.getInstance().getStartupWindowWidth()+"";

double screenHeight = Config.getInstance().getStartupWindowHeight();

String screenHeight = Config.getInstance().getStartupWindowHeight()+"";

Platform OS = clientInfo.getPlatformType();

String OS = clientInfo.getPlatformType()+"";

String defaultProfileID = Config.getInstance().getStartupProfileID();

writeToStream("client_details::"+

clientVersion.getText()+"::"+

Message toBeSent = new Message("client_details");

releaseStatus+"::"+

toBeSent.setStringArrValue(

clientCommsStandard.getText()+"::"+

clientVersion,

clientMinThemeStandard.getText()+"::"+

releaseStatus,

clientNickname+"::"+

clientCommsStandard,

screenWidth+"::"+

clientMinThemeStandard,

screenHeight+"::"+

clientNickname,

OS+"::" +

screenWidth,

defaultProfileID+"::"+

screenHeight,

clientListener.getDefaultThemeFullName()+"::");

OS,

defaultProfileID,

clientListener.getDefaultThemeFullName()

);

sendMessage(toBeSent);

}

public void sendProfileNamesToServer() throws SevereException

{

StringBuilder finalQuery = new StringBuilder("profiles::");

Message message = new Message("profiles");

finalQuery.append(clientListener.getClientProfiles().getClientProfiles().size()).append("::");

String[] arr = new String[clientListener.getClientProfiles().getClientProfiles().size()];

for(ClientProfile clientProfile : clientListener.getClientProfiles().getClientProfiles())

for(int i = 0;i<arr.length;i++)

{

finalQuery.append(clientProfile.getID()).append("::");

ClientProfile clientProfile = clientListener.getClientProfiles().getClientProfiles().get(i);

arr[i] = clientProfile.getID();

}

writeToStream(finalQuery.toString());

message.setStringArrValue(arr);

sendMessage(message);

}

public void sendProfileDetailsToServer(String ID) throws SevereException

public void sendProfileDetailsToServer(Message message) throws SevereException

{

StringBuilder finalQuery = new StringBuilder("profile_details::");

String ID = message.getStringValue();

ClientProfile clientProfile = clientListener.getClientProfiles().getProfileFromID(ID);

finalQuery.append(ID).append("::");

Message tbs1 = new Message("profile_details");

finalQuery.append(clientProfile.getName())

ClientProfile clientProfile = clientListener.getClientProfiles().getProfileFromID(ID);

.append("::")

.append(clientProfile.getRows())

.append("::")

.append(clientProfile.getCols())

.append("::")

.append(clientProfile.getActionSize())

.append("::")

.append(clientProfile.getActionGap())

.append("::");

String[] arr = new String[]{

clientProfile.getName(),

clientProfile.getRows()+"",

clientProfile.getCols()+"",

clientProfile.getActionSize()+"",

clientProfile.getActionGap()+""

};

writeToStream(finalQuery.toString());

tbs1.setStringArrValue(arr);

sendMessage(tbs1);

for(Action action : clientProfile.getActions())

{

sendActionDetails(clientProfile.getID(), action);

}

for(Action action : clientProfile.getActions())

{

if(action.isHasIcon())

{

System.out.println("23123123123 : "+action.getID() + action.isHasIcon());

sendActionIcon(clientProfile.getID(), action.getID());

}

public void sendActionDetails(String profileID, Action action) throws SevereException {

if(action == null)

{

logger.info("NO SUCH ACTION");

return;

}

StringBuilder finalQuery = new StringBuilder("action_details::");

ArrayList<String> a = new ArrayList<>();

finalQuery.append(profileID)

a.add(profileID);

.append("::")

a.add(action.getID());

.append(action.getID())

a.add(action.getActionType()+"");

.append("::")

.append(action.getActionType())

.append("::");

if(action.getActionType() == ActionType.NORMAL) {

finalQuery.append(action.getVersion().getText());

a.add(action.getVersion().getText());

}

else

{

a.add("no");

}

finalQuery.append("::");

if(action.getActionType() ==ActionType.NORMAL)

{

finalQuery.append(action.getModuleName());

a.add(action.getModuleName());

}

else

{

a.add("nut");

}

finalQuery.append("::");

//display

finalQuery.append(action.getBgColourHex())

a.add(action.getBgColourHex());

.append("::");

//icon

finalQuery.append(action.isHasIcon())

a.add(action.isHasIcon()+"");

.append("::")

a.add(action.isShowIcon()+"");

.append(action.isShowIcon())

.append("::");

//text

finalQuery.append(action.isShowDisplayText())

a.add(action.isShowDisplayText()+"");

.append("::")

a.add(action.getDisplayTextFontColourHex());

.append(action.getDisplayTextFontColourHex())

a.add(action.getDisplayText());

.append("::")

a.add(action.getDisplayTextAlignment()+"");

.append(action.getDisplayText())

.append("::")

.append(action.getDisplayTextAlignment())

.append("::");

//location

if(action.getLocation() == null)

finalQuery.append("-1::-1::");

{

a.add("-1");

}

else

finalQuery.append(action.getLocation().getRow())

{

.append("::")

a.add(action.getLocation().getRow()+"");

.append(action.getLocation().getCol())

a.add(action.getLocation().getCol()+"");

.append("::");

}

//client properties

ClientProperties clientProperties = action.getClientProperties();

finalQuery.append(clientProperties.getSize())

a.add(clientProperties.getSize()+"");

.append("::");

for(Property property : clientProperties.get())

{

finalQuery.append(property.getName())

a.add(property.getName());

.append("__")

a.add(property.getRawValue());

.append(property.getRawValue())

.append("__");

finalQuery.append("!!");

}

finalQuery.append("::")

a.add(action.getParent());

.append(action.getParent())

.append("::");

writeToStream(finalQuery.toString());

Message message = new Message("action_details");

String[] x = new String[a.size()];

x = a.toArray(x);

message.setStringArrValue(x);

sendMessage(message);

}

public void saveActionDetails(String[] sep)

public void saveActionDetails(Message message)

{

String profileID = sep[1];

String[] r = message.getStringArrValue();

String profileID = r[0];

String ID = sep[2];

String ID = r[1];

ActionType actionType = ActionType.valueOf(sep[3]);

ActionType actionType = ActionType.valueOf(r[2]);

//4 - Version

//3 - Version

//5 - ModuleName

//4 - ModuleName

//display

String bgColorHex = sep[6];

String bgColorHex = r[5];

//icon

boolean isHasIcon = sep[7].equals("true");

boolean isHasIcon = r[6].equals("true");

boolean isShowIcon = sep[8].equals("true");

boolean isShowIcon = r[7].equals("true");

//text

boolean isShowDisplayText = sep[9].equals("true");

boolean isShowDisplayText = r[8].equals("true");

String displayFontColor = sep[10];

String displayFontColor = r[9];

String displayText = sep[11];

String displayText = r[10];

DisplayTextAlignment displayTextAlignment = DisplayTextAlignment.valueOf(sep[12]);

DisplayTextAlignment displayTextAlignment = DisplayTextAlignment.valueOf(r[11]);

//location

String row = sep[13];

String row = r[12];

String col = sep[14];

String col = r[13];

Location location = new Location(Integer.parseInt(row), Integer.parseInt(col));

Action action = new Action(ID, actionType);

if(actionType == ActionType.NORMAL)

{

try

{

action.setVersion(new Version(sep[4]));

action.setVersion(new Version(r[3]));

action.setModuleName(sep[5]);

action.setModuleName(r[4]);

}

catch (Exception e)

{

logger.severe(e.getMessage());

e.printStackTrace();

}

action.setBgColourHex(bgColorHex);

action.setShowIcon(isShowIcon);

action.setHasIcon(isHasIcon);

System.out.println("IS HAS ICON : "+isHasIcon+", IS SHOW ICON :"+isShowIcon);

action.setShowDisplayText(isShowDisplayText);

action.setDisplayTextFontColourHex(displayFontColor);

action.setDisplayText(displayText);

action.setDisplayTextAlignment(displayTextAlignment);

action.setLocation(location);

//client properties

int clientPropertiesSize = Integer.parseInt(sep[15]);

int clientPropertiesSize = Integer.parseInt(r[14]);

String[] clientPropertiesRaw = sep[16].split("!!");

String[] clientPropertiesRaw = r[15].split("!!");

ClientProperties clientProperties = new ClientProperties();

if(actionType == ActionType.FOLDER)

clientProperties.setDuplicatePropertyAllowed(true);

for(int i = 0;i<clientPropertiesSize; i++)

{

String[] clientPraw = clientPropertiesRaw[i].split("__");

Property property = new Property(clientPraw[0], Type.STRING);

if(clientPraw.length > 1)

property.setRawValue(clientPraw[1]);

clientProperties.addProperty(property);

}

action.setClientProperties(clientProperties);

String parent = sep[17];

String parent = r[16];

action.setParent(parent);

try

{

Action old = clientListener.getClientProfiles().getProfileFromID(profileID).getActionFromID(action.getID());

if(old != null)

{

if(action.isHasIcon())

action.setIcon(clientListener.getClientProfiles().getProfileFromID(profileID).getActionFromID(action.getID()).getIconAsByteArray());

}

clientListener.getClientProfiles().getProfileFromID(profileID).addAction(action);

System.out.println("XXXXXXXXXXX " +action.isHasIcon());

//clientListener.getClientProfiles().getProfileFromID(profileID).saveActions();

clientListener.getClientProfiles().getProfileFromID(profileID).saveAction(action);

if(clientListener.getCurrentProfile().getID().equals(profileID) && action.getLocation().getCol()!=-1)

{

javafx.application.Platform.runLater(()->{

ActionBox box = clientListener.getActionBox(action.getLocation().getCol(), action.getLocation().getRow());

System.out.println(box==null);

System.out.println("GATYYY : "+action.getLocation().getCol()+","+action.getLocation().getRow());

System.out.println("jj : "+action.getLocation().getCol()+","+action.getLocation().getRow());

box.clear();

box.setAction(action);

if(box!=null)

box.baseInit();

{

box.init();

box.clear();

box.setAction(action);

box.baseInit();

box.init();

}

});

}

//clientListener.clearActionBox(action.getLocation().getCol(), action.getLocation().getRow());

//clientListener.renderAction(profileID, action);

}

catch (Exception e)

{

e.printStackTrace();

exceptionAndAlertHandler.handleMinorException(new MinorException(e.getMessage()));

}

public void deleteAction(String profileID, String actionID)

public void deleteAction(Message message)

{

try

{

String[] arr = message.getStringArrValue();

String profileID = arr[0];

String actionID = arr[1];

Action acc = clientListener.getClientProfiles().getProfileFromID(profileID).getActionFromID(actionID);

if(acc.getActionType() == ActionType.FOLDER)

{

ArrayList<String> idsToBeRemoved = new ArrayList<>();

ArrayList<String> folders = new ArrayList<>();

String folderToBeDeletedID = clientListener.getClientProfiles().getProfileFromID(profileID).getActionFromID(actionID).getID();

folders.add(folderToBeDeletedID);

boolean startOver = true;

while(startOver)

{

startOver = false;

for(Action action : clientListener.getClientProfiles().getProfileFromID(profileID).getActions())

{

if(folders.contains(action.getParent()))

{

if(!idsToBeRemoved.contains(action.getID()))

{

idsToBeRemoved.add(action.getID());

if(action.getActionType() == ActionType.FOLDER)

{

folders.add(action.getID());

startOver = true;

}

for(String ids : idsToBeRemoved)

{

clientListener.getClientProfiles().getProfileFromID(profileID).removeAction(ids);

}

else if (acc.getActionType() == ActionType.COMBINE)

{

for(Property property : acc.getClientProperties().get())

{

clientListener.getClientProfiles().getProfileFromID(profileID).removeAction(property.getRawValue());

}

clientListener.getClientProfiles().getProfileFromID(profileID).removeAction(acc.getID());

clientListener.getClientProfiles().getProfileFromID(profileID).saveActions();

if(acc.getLocation().getCol()!=-1)

{

clientListener.clearActionBox(acc.getLocation().getCol(), acc.getLocation().getRow());

clientListener.addBlankActionBox(acc.getLocation().getCol(), acc.getLocation().getRow());

}

catch (Exception e)

{

e.printStackTrace();

exceptionAndAlertHandler.handleMinorException(new MinorException(e.getMessage()));

}

public void saveClientDetails(String[] sep)

public void saveClientDetails(Message message)

{

try

{

String[] sep = message.getStringArrValue();

Config.getInstance().setNickName(sep[1]);

Config.getInstance().setNickName(sep[0]);

String oldWidth = Config.getInstance().getStartupWindowWidth()+"";

String oldHeight = Config.getInstance().getStartupWindowHeight()+"";

Config.getInstance().setStartupWindowSize(

Double.parseDouble(sep[2]),

Double.parseDouble(sep[1]),

Double.parseDouble(sep[3])

Double.parseDouble(sep[2])

);

Config.getInstance().setStartupProfileID(sep[4]);

Config.getInstance().setStartupProfileID(sep[3]);

String oldThemeFullName = Config.getInstance().getCurrentThemeFullName();

Config.getInstance().setCurrentThemeFullName(sep[5]);

Config.getInstance().setCurrentThemeFullName(sep[4]);

if(!oldHeight.equals(sep[3]) || !oldWidth.equals(sep[2]) || !oldThemeFullName.equals(sep[5]))

if(!oldHeight.equals(sep[2]) || !oldWidth.equals(sep[1]) || !oldThemeFullName.equals(sep[4]))

javafx.application.Platform.runLater(()-> clientListener.init());

javafx.application.Platform.runLater(clientListener::init);

Config.getInstance().save();

javafx.application.Platform.runLater(()->clientListener.loadSettings());

javafx.application.Platform.runLater(clientListener::loadSettings);

}

catch (SevereException e)

{

e.printStackTrace();

exceptionAndAlertHandler.handleSevereException(e);

}

public void saveProfileDetails(String[] sep) throws SevereException, MinorException

public void saveProfileDetails(Message message) throws SevereException, MinorException

{

ClientProfile clientProfile = clientListener.getClientProfiles().getProfileFromID(sep[1]);

String[] sep = message.getStringArrValue();

ClientProfile clientProfile = clientListener.getClientProfiles().getProfileFromID(sep[0]);

if(clientProfile == null)

{

clientProfile = new ClientProfile(new File(Config.getInstance().getProfilesPath().toString()+"/"+sep[1]+".xml"),

clientProfile = new ClientProfile(new File(Config.getInstance().getProfilesPath()+"/"+sep[0]+".xml"),

Config.getInstance().getIconsPath());

}

clientProfile.setName(sep[2]);

clientProfile.setName(sep[1]);

clientProfile.setRows(Integer.parseInt(sep[3]));

clientProfile.setRows(Integer.parseInt(sep[2]));

clientProfile.setCols(Integer.parseInt(sep[4]));

clientProfile.setCols(Integer.parseInt(sep[3]));

clientProfile.setActionSize(Integer.parseInt(sep[5]));

clientProfile.setActionSize(Integer.parseInt(sep[4]));

clientProfile.setActionGap(Integer.parseInt(sep[6]));

clientProfile.setActionGap(Integer.parseInt(sep[5]));

try

{

clientListener.getClientProfiles().addProfile(clientProfile);

clientProfile.saveProfileDetails();

clientListener.refreshGridIfCurrent(sep[1]);

clientListener.refreshGridIfCurrent(sep[0]);

javafx.application.Platform.runLater(()->clientListener.loadSettings());

javafx.application.Platform.runLater(clientListener::loadSettings);

}

catch (Exception e)

{

e.printStackTrace();

throw new SevereException(e.getMessage());

}

public void deleteProfile(String ID)

public void deleteProfile(Message message)

{

clientListener.getClientProfiles().deleteProfile(clientListener.getClientProfiles().getProfileFromID(ID));

clientListener.getClientProfiles().deleteProfile(clientListener.getClientProfiles().getProfileFromID(

message.getStringValue()

));

}

public void onActionClicked(String profileID, String actionID) throws SevereException {

writeToStream("action_clicked::"+profileID+"::"+actionID+"::");

Message m = new Message("action_clicked");

m.setStringArrValue(profileID, actionID);

sendMessage(m);

}

public void actionFailed(String profileID, String actionID)

public void actionFailed(Message message)

{

String[] r = message.getStringArrValue();

String profileID = r[0];

String actionID = r[1];

clientListener.onActionFailed(profileID, actionID);

}

client

Clone or download

Fully refactored Client comms

Modified Files

Public

client

Clone or download

Fully refactored Client comms

Modified Files