package org.spiderwiz.tutorial.objectLib;

import org.spiderwiz.annotation.WizField;
import org.spiderwiz.core.DataObject;

/**
 * ChatRoom class for Spiderwiz tutorial
 */
public class ChatRoom extends DataObject{
    /**
     * Mandatory public static field for all data objects.
     */
    public final static String ObjectCode = "CHTRM";

    @WizField boolean adult = false;        // Indicates whether this is an adult only chat room. False by default.

    public synchronized boolean isAdult() {
        return adult;
    }

    public synchronized void setAdult(boolean adult) {
        this.adult = adult;
    }

    /**
     * @return null as this is a root object.
     */
    @Override
    protected String getParentCode() {
        return null;
    }

    /**
     * @return false because objects of this class are persistent
     */
    @Override
    protected boolean isDisposable() {
        return false;
    }

    /**
     * @return false because chat room names are case insensitive.
     */
    @Override
    protected boolean isCaseSensitive() {
        return false;
    }
}

package org.spiderwiz.tutorial.objectLib;

import org.spiderwiz.annotation.WizField;
import org.spiderwiz.core.DataObject;

/**
 * A data object that represents a chat user in a specific chat room
 */
public class Chatter extends DataObject {
    /**
     * Mandatory public static field for all data objects.
     */
    public final static String ObjectCode = "CHTTR";
    
    @WizField private String name;              // Contains the name of the chatter

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    /**
     * @return ChatRoom object code
     */
    @Override
    protected String getParentCode() {
        return ChatRoom.ObjectCode;
    }

    /**
     * @return false because objects of this class are persistent
     */
    @Override
    protected boolean isDisposable() {
        return false;
    }
}

package org.spiderwiz.tutorial.objectLib;

import org.spiderwiz.annotation.WizField;
import org.spiderwiz.core.DataObject;

/**
 * A data object representing a message sent in chat room
 */
public class ChatMessage extends DataObject {
    /**
     * Mandatory public static field for all data objects.
     */
    public final static String ObjectCode = "CHTMSG";
    
    @WizField private String message;                   // Contains a chat message

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    /**
     * @return Chatter object code
     */
    @Override
    protected String getParentCode() {
        return Chatter.ObjectCode;
    }

    /**
     * @return true as this object is disposable.
     */
    @Override
    protected boolean isDisposable() {
        return true;
    }

    @Override
    protected boolean isUrgent() {
        return true;
    }
}

package org.spiderwiz.tutorial.lesson5.roomManager;

import java.util.List;
import org.spiderwiz.core.DataObject;
import org.spiderwiz.tutorial.objectLib.ChatRoom;
import org.spiderwiz.tutorial.objectLib.ConsoleMain;

/**
 * Provides the entry point of the application. Initializes and executes the Spiderwiz framework.
 */
public class RoomManagerMain extends ConsoleMain {
    private static final String ROOT_DIRECTORY = "";
    private static final String CONF_FILENAME = "room-manager.conf";
    private static final String APP_NAME = "Room Manager";
    private static final String APP_VERSION = "Z1.01";  // Version Z1.01: Initial version

    private static final String CREATE = "create";  // create chat room command
    private static final String DELETE = "delete";  // delete chat room command
    private static final String MODIFY = "modify";  // modify chat room command
    private static final String RENAME = "rename";  // rename chat room command
    
    /**
     * Class constructor with constant parameters.
     */
    public RoomManagerMain() {
        super(ROOT_DIRECTORY, CONF_FILENAME, APP_NAME, APP_VERSION);
    }
    
    /**
     * Application entry point. Instantiate the class and initialize the instance.
     * 
     * @param args the command line arguments. Not used in this application.
     */
    public static void main(String[] args) {
        new RoomManagerMain().init();
    }

    /**
     * Print out usage instructions at start up
     * @return true
     */
    @Override
    protected boolean preStart() {
        System.out.printf(
            "To create a new room: type 'create <room name>'.n"
                + "Append a plus sign (+) to the name if you want to create an adult only room.n"
                + "To delete a room type 'delete <room name>'.n"
                + "To modify the adult categorization of a room:n"
                + "Type 'modify <room name>+' if you want to make it an adult room.n"
                + "Type 'modify <room name>' if you want to remove the adult categorization.n"
                + "To rename a room type 'rename <room name>=<new name>'.n"
                + "To exit type 'exit'.n"
        );
        return true;
    }

    /**
     * @return the list of produced objects, in this case ChatRoom is the only one.
     */
    @Override
    protected String[] getProducedObjects() {
        return new String[]{ChatRoom.ObjectCode};
    }

    /**
     * @return the list of consumed objects, in this case we do not consume any so we return an empty list.
     */
    @Override
    protected String[] getConsumedObjects() {
        return new String[]{};
    }

    /**
     * Add ChatRoom class to the object factory list of this application.
     * @param factoryList
     */
    @Override
    protected void populateObjectFactory(List<Class<? extends DataObject>> factoryList) {
        super.populateObjectFactory(factoryList);
        factoryList.add(ChatRoom.class);
    }

    /**
     * Process an input line
     * @param line      An input line that contains a room management command
     * @return true if processed successfully
     */
    @Override
    protected boolean processConsoleLine(String line) {
        try {
            // Trim line and split to command / parameter.
            // Then check if there is a parameter and whether it contains the adult symbol.
            // If there is not parameter, ignore the command.
            String command[] = line.trim().split("s+", 2);
            if (command.length < 2)
                return true;
            String name[] = command[1].split("+", -1);
            boolean adult = name.length > 1;
            // now split for 'rename' command
            name = name[0].split("=");
            String roomName = name[0];
            
            // If exists, get the ChatRoom object
            ChatRoom room = getRootObject().getChild(ChatRoom.class, roomName);
            
            // Switch by command and process it
            switch (command[0].toLowerCase()) {
            case CREATE:
                // Create a new room if does not exist (ignore if it does)
                if (room == null) {
                    room = createTopLevelObject(ChatRoom.class, roomName);
                    room.setAdult(adult);
                    room.commit();
                    System.out.printf("Room %1$s(%2$s) createdn", roomName, adult ? "adult" : "unrestricted");
                }
                break;
            case DELETE:
                // Delete the room if exists
                if (room != null) {
                    room.remove();
                    room.commit();
                    System.out.printf("Room %1$s deletedn", roomName);
                }
                break;
            case MODIFY:
                // Modify the 'adult' field if the room exits
                if (room != null) {
                    room.setAdult(adult);
                    room.commit();
                    System.out.printf("Room %1$s set to %2$sn", roomName, adult ? "adult" : "unrestricted");
                }
                break;
            case RENAME:
                // Rename the room if exists. The rename command is 'rename <old name>=<new name>'
                if (room != null && name.length > 1) {
                    String newName = name[1];
                    if (!newName.equalsIgnoreCase(roomName)) {
                        DataObject renamed = room.rename(newName);
                        if (renamed == null)
                            System.out.printf("Cannot rename to already existing room name %sn", newName);
                        else {
                            renamed.commit();
                            System.out.printf("Room %1$s was renamed %2$sn", roomName, newName);
                        }
                    }
                }
            }
            return true;
        } catch (NoSuchFieldException | IllegalAccessException ex) {
            // Theoretically arriving here if any data object does not contain ObjectCode static field or the field is not public.
            // In this case, send a command exception message.
            sendExceptionMail(ex, "Cannot instantiate a data object class", null, false);
            return false;
        }
    }
}

[log folder]Logs
[consumer server-1]websocket;ping-rate=30
[producer server-1]websocket;ping-rate=30
[consumer server-2]port=10001
[hub mode]yes

[log folder]/tests/RoomManager/Logs
[producer-1]ip=localhost;port=10001

package org.spiderwiz.tutorial.lesson5.chat;

import java.util.List;
import java.util.UUID;
import org.spiderwiz.admin.xml.OpResultsEx;
import org.spiderwiz.core.DataObject;
import org.spiderwiz.tutorial.objectLib.Chat;
import org.spiderwiz.tutorial.objectLib.ChatMessage;
import org.spiderwiz.tutorial.objectLib.ChatRoom;
import org.spiderwiz.tutorial.objectLib.Chatter;
import org.spiderwiz.tutorial.objectLib.ConsoleMain;

/**
 * Provides the entry point of the application. Initializes and executes the Spiderwiz framework.
 */
public class ChatMain extends ConsoleMain{
    private static final String ROOT_DIRECTORY = "";
    private static final String APP_NAME = "Dynamic Chat Room Client";
    private static final String APP_VERSION = "Z1.01";  // Version Z1.01: Initial version

    private static final String JOIN = "!join";         // join a chat room command
    private static final String LEAVE = "!leave";       // leave current chat room command
    
    private String myName;                      // Get this from the configuration file
    private Chatter chatter = null;             // A Chatter object representing the user chatting in a specific room
    private ChatMessage message = null;         // A ChatMessage object for committing chat messages
    private Chat privateMessage = null;         // A Chat object for committing private messages
    private UUID lastSender = null;             // Stores the application UUID of the last received message

    /**
     * Class constructor with constant parameters.
     * @param confFileName  configuration file name, provided as a command argument
     */
    public ChatMain(String confFileName) {
        super(ROOT_DIRECTORY, confFileName, APP_NAME, APP_VERSION);
    }
    
    /**
     * @return the class instance as ChatMain type.
     */
    public static ChatMain getInstance() {
        return (ChatMain)ConsoleMain.getInstance();
    }

    public synchronized UUID getLastSender() {
        return lastSender;
    }

    public synchronized void setLastSender(UUID lastSender) {
        this.lastSender = lastSender;
    }

    /**
     * Application entry point. Instantiate the class and initialize the instance.
     * 
     * @param args the command line arguments. The first argument is used as the configuration file name.
     */
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // Don't do anything if there is no configuration file name
        if (args.length == 0) {
            System.out.println("Configuration file has not been defined");
            return;
        }
        new ChatMain(args[0]).init();
    }

    /**
     * Before starting Spiderwiz engine (but after reading program configuration) get the chatter name,
     * then print user instructions to the console.
     * @return true if the name is provided, false if not.
     */
    @Override
    protected boolean preStart() {
        myName = getConfig().getProperty("my name");
        if (myName == null || myName.isBlank()) {
            System.out.println("Chatter name has not been defined");
            return false;
        }
        System.out.printf(
            "Hello %s. Welcome to the dynamic chat system.n"
                + "To join a chat room or change your current chat room, type "!join <room name>".n"
                + "To leave your chat room, type "!leave".n"
                + "To send a message in the current chat room just type the message "
                + "(a message cannot start with either '>' or '!').n"
                + "To send a private message to the sender of the last message you have received "
                + "type '>' followed by the message.n"
                + "To exit type 'exit'.n",
            myName
        );
        return true;
    }
    
    /**
     * @return the list of produced objects - Chatter, Chat and ChatMessage
     */
    @Override
    protected String[] getProducedObjects() {
        return new String[]{
            Chatter.ObjectCode,
            Chat.ObjectCode,
            ChatMessage.ObjectCode
        };
    }

    /**
     * @return the list of consumed objects - ChatRoom, Chatter, Chat and ChatMessage
     */
    @Override
    protected String[] getConsumedObjects() {
        return new String[]{
            ChatRoom.ObjectCode,
            Chatter.ObjectCode,
            Chat.ObjectCode,
            ChatMessage.ObjectCode
        };
    }

    /**
     * Add implementation classes to the object factory list of this application.
     * @param factoryList
     */
    @Override
    protected void populateObjectFactory(List<Class<? extends DataObject>> factoryList) {
        super.populateObjectFactory(factoryList);
        factoryList.add(ChatRoomConsume.class);
        factoryList.add(ChatterConsume.class);
        factoryList.add(ChatConsume.class);
        factoryList.add(ChatMessageImp.class);
    }

    /**
     * @return true if application is configured as an adult chatter
     */
    public boolean isAdult() {
        return getConfig().isPropertySet("adult");
    }

    /**
     * Join a room after checking that the room exists, its adult setting matches user configuration,
     * and the user is not already there. If the user is in another room leave that room first.
     * @param room  the new room name
     * @throws NoSuchFieldException     If any of the created data objects does not define ObjectCode static field.
     * @throws IllegalAccessException   If ObjectCode is not public.
     */
    private void joinRoom(String room) throws NoSuchFieldException, IllegalAccessException {
        ChatRoom chatRoom = getRootObject().getChild(ChatRoom.class, room);
        if (chatRoom == null) {
            System.out.printf("Room %s does not existn", room);
            return;
        }

        if (chatter != null && room.equalsIgnoreCase(chatter.getParent().getObjectID()))
            return;
        if (chatRoom.isAdult() && !isAdult()) {
            System.out.printf("You cannot join room %s because it is only for adultsn", room);
            return;
        }
        leaveRoom(null);
        chatter = chatRoom.createChild(Chatter.class, getAppUUID().toString());
        chatter.setName(myName);
        chatter.commit();       // let everybody know I joined the room
        // Prepare a ChatMessage object for sending messages from now on
        message = chatter.createChild(ChatMessage.class, null);
        System.out.printf("Joined room %sn", room);
    }
    
    /**
     * If the user is in the given room, leave it.
     * @param room  the name of the room to be checked if the user is there. If null, leave the current room without checking
     */
    public synchronized void leaveRoom(String room) {
        if (isSameRoom(room)) {
            chatter.remove();       // leave the room
            chatter.commit();       // let everybody know I did
            System.out.printf("Left room %sn", chatter.getParent().getObjectID());
            chatter = null;
            message = null;
        }
    }
    
    /**
     * Check if the user is in the same room as the parameter
     * @param room  the name of the room to be checked if the user is there. If null, return true
     * @return true if the user in 'room' or 'room' is null
     */
    public synchronized boolean isSameRoom(String room) {
        return chatter != null &&
            (room == null || room.equalsIgnoreCase(chatter.getParent().getObjectID()));
    }
    
    /**
     * Check whether the user running the application whose UUID is given is on the same room as us. This is done by getting
     * our current ChatRoom object and see if it has a child with that ID.
     * @param appUUID   Application UUID to check
     * @return  true if the application is in the same room as us.
     */
    public synchronized boolean isMemberOfMyRoom(UUID appUUID) {
        try {
            if (chatter == null)
                return false;
            ChatRoom chatRoom = (ChatRoom)chatter.getParent();
            return chatRoom != null && chatRoom.getChild(Chatter.class, appUUID.toString()) != null;
        } catch (NoSuchFieldException | IllegalAccessException ex) {
            // Theoretically arriving here if a data object does not contain ObjectCode static field or the field is not public.
            // In this case, send a command exception message.
            sendExceptionMail(ex, "Cannot instantiate a data object class", null, false);
            return false;
        }
    }

    /**
     * Called when application configuration has been changed. If the user were changed to "not adult" and she is on
     * a room defined as adult only then take the user out of the room.
     * @return the value returned by the super method.
     */
    @Override
    public OpResultsEx reloadConfig() {
        OpResultsEx opResult = super.reloadConfig();
        if (chatter != null)
            ((ChatRoomConsume)chatter.getParent()).reloadConfig();
        return opResult;
    }
    
    /**
     * Process an input line
     * @param line      the line to be broadcast as a chat message.
     * @return true if processed successfully
     */
    @Override
    protected boolean processConsoleLine(String line) {
        try {
            // If the line starts with '!' this is a command line
            if (line.startsWith("!")) {
                String command[] = line.trim().split("s+", 2);
                switch (command[0].toLowerCase()) {
                case JOIN:
                    // if room name is provided join the room
                    if (command.length > 1)
                        joinRoom(command[1]);
                    break;
                case LEAVE:
                    // If the user is in a room, leave it
                    leaveRoom(null);
                    break;
                }
                return true;
            }
            
            // If the line starts with '>' send a private message to the sender of the last received message
            if (line.startsWith(">")) {
                if (getLastSender() == null)
                    return true;
                // If didn't do yet, create an orphan Chatter object for sending private messages,
                // then prepare a ChatMessage object for sending private messages
                if (privateMessage == null) {
                    privateMessage = createTopLevelObject(Chat.class, null);
                    privateMessage.setName(myName);
                }
                // Set message and commit to destination
                privateMessage.setMessage(line.substring(1));
                privateMessage.commit(getLastSender().toString());
                return true;
            }
            
            // If this is a normal message, make sure the user is in a room and broadcast the message
            if (message != null) {
                message.setMessage(line);
                message.commit();
            }
            return true;
        } catch (NoSuchFieldException | IllegalAccessException ex) {
            // Theoretically arriving here if a data object does not contain ObjectCode static field or the field is not public.
            // In this case, send a command exception message.
            sendExceptionMail(ex, "Cannot instantiate a data object class", null, false);
            return false;
        }
    }
}

package org.spiderwiz.tutorial.lesson5.chat;

import org.spiderwiz.tutorial.objectLib.ChatRoom;

/**
 * Consumer implementation of the ChatRoom class
 */
public class ChatRoomConsume extends ChatRoom {

    /**
     * If the chat room has been removed and the user is there, leave the room
     * @return true to confirm the removal.
     */
    @Override
    protected boolean onRemoval() {
        ChatMain.getInstance().leaveRoom(getObjectID());
        return true;
    }

    /**
     * If the room was set to adult and user is not configured as such, leave the room if user is there
     * @return true
     */
    @Override
    protected boolean onEvent() {
        if (isAdult() && !ChatMain.getInstance().isAdult())
            ChatMain.getInstance().leaveRoom(getObjectID());
        return true;
    }

    /**
     * Notify on room name change if the user is in the renamed room
     * @param oldID
     */
    @Override
    protected void onRename(String oldID) {
        if (ChatMain.getInstance().isSameRoom(getObjectID()))
            System.out.printf("Your room %1$s was renamed %2$sn", oldID, getObjectID());
    }
    
    /**
     * Called when application configuration has been changed. If the user were changed to "not adult" and the room is an adult room
     * then onEvent() would take the user out of the room.
     */
    public void reloadConfig() {
        onEvent();
    }
}

package org.spiderwiz.tutorial.lesson5.chat;

import org.spiderwiz.tutorial.objectLib.Chatter;

/**
 * Consumer implementation of Chatter data object. Notify when a chatter enters or leaves my room.
 */
public class ChatterConsume extends Chatter {

    /**
     * Notify when a chatter enters my room.
     */
    @Override
    protected void onNew() {
        // The room is the parent of this object
        if (ChatMain.getInstance().isSameRoom((getParent().getObjectID())))
            System.out.printf("%s entered the roomn", getName());
    }

    /**
     * Notify when a chatter leaves my room
     * @return true to confirm the removal.
     */
    @Override
    protected boolean onRemoval() {
        // The room is the parent of this object
        if (ChatMain.getInstance().isSameRoom(getParent().getObjectID()))
            System.out.printf("%s left the roomn", getName());
        return true;
    }
}

package org.spiderwiz.tutorial.lesson5.chat;

import java.util.Map;
import java.util.UUID;
import org.spiderwiz.tutorial.objectLib.ChatMessage;
import org.spiderwiz.tutorial.objectLib.Chatter;

/**
 * Consumer implementation of the ChatMessage class
 */
public class ChatMessageImp extends ChatMessage {
    /**
     * Called when a chat message is received. Check if the message has been sent in the room we are in,
     * Then print the sender name and the message.
     * Store the sender UUID for private messaging.
     * @return true to indicate that the event has been handled.
     */
    @Override
    protected boolean onEvent() {
        if (ChatMain.getInstance().isSameRoom(getParent().getParent().getObjectID())) {
            System.out.printf("%1$s: %2$sn", ((Chatter)getParent()).getName(), getMessage());
            ChatMain.getInstance().setLastSender(getOriginUUID());
        }
        return true;
    }

    /**
     * Restrict message sending to:
     *      1. applications that are not the current application.
     *      2. applications that are on the same chat room as the current user
     * @param appUUID           destination application UUID
     * @param appName           destination application name
     * @param userID            destination user ID
     * @param remoteAddress     remote network address
     * @param appParams         application parameters of the destination application
     * @return true if the object should be sent to this destination
     */
    @Override
    protected boolean filterDestination(UUID appUUID, String appName, String userID, String remoteAddress,
        Map<String, String> appParams
    ) {
        return
            !ChatMain.getInstance().getAppUUID().equals(appUUID) &&
            ChatMain.getInstance().isMemberOfMyRoom(appUUID);
    }
}

package org.spiderwiz.tutorial.lesson5.chat;

import org.spiderwiz.tutorial.objectLib.Chat;

/**
 * Consumer implementation of the Chat class
 */
public class ChatConsume extends Chat{

    /**
     * Called when a private message is received. Print the sender name followed by a colon, then the message.
     * @return true to indicate that the event has been handled.
     */
    @Override
    protected boolean onEvent() {
        System.out.printf("%1$s: %2$sn", getName(), getMessage());
        return true;
    }
}

[application name]Chat 1
[log folder]/tests/Chat1/Logs
[producer-1]websocket=localhost:90/MyHub
[my name]FERRANDO

[application name]Chat 2
[log folder]/tests/Chat2/Logs
[producer-1]websocket=localhost:90/MyHub
[my name]GUGLIELMO

[log folder]/tests/Chat3/Logs
[producer-1]websocket=localhost:90/MyHub
[my name]DON ALFONSO
[adult]yes