package org.spiderwiz.tutorial.lesson12.archiver;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.spiderwiz.core.DataObject;
import org.spiderwiz.tutorial.objectLib.ChatApp;
import org.spiderwiz.tutorial.objectLib.ChatHistoryQuery;
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 ArchiverMain extends ConsoleMain {
    private static final String ROOT_DIRECTORY = "";
    private static final String CONF_FILENAME = "archiver.conf";
    private static final String APP_NAME = "Chat Archiver";
    private static final String APP_VERSION = "Z1.01";  // Version Z1.01: Initial version
    static final String MY_USERNAME = "_chat_message_archiver";  // Use this as the "chatter" name when joining a room

    /**
     * Class constructor with constant parameters. Call super constructor and create the user map.
     */
    public ArchiverMain() {
        super(ROOT_DIRECTORY, CONF_FILENAME, APP_NAME, APP_VERSION);
    }
    
    /**
     * @return the class instance as ArchiverMain type.
     */
    public static ArchiverMain getInstance() {
        return (ArchiverMain)ConsoleMain.getInstance();
    }

    /**
     * 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 ArchiverMain().init();
    }

    /**
     * @return an empty list
     */
    @Override
    protected String[] getProducedObjects() {
        return new String[]{};
    }

    /**
     * @return the list of consumed objects
     */
    @Override
    protected String[] getConsumedObjects() {
        return new String[]{
            ChatMessage.ObjectCode + ChatMessage.Lossless,  // Listens to every message for archiving.in lossless mode
            ChatHistoryQuery.ObjectCode                     // Replier of this query.
        };
    }

    /**
     * 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(ChatRoom.class);
        factoryList.add(ChatApp.class);
        factoryList.add(Chatter.class);
        factoryList.add(ChatMessageArchiver.class);
        factoryList.add(ChatHistoryQueryReply.class);
        factoryList.add(ArchivedUser.class);
        factoryList.add(ArchivedChatItem.class);
    }

    /**
     * @return a map with 'role'->'admin' mapping
     */
    @Override
    public Map<String, String> getAppParams() {
        return new HashMap<>() {
            {
                put("role", "admin");
            }
        };
    }
    
    /**
     * Process an input line - nothing to process in our case.
     * @param line      The input line
     * @return true
     */
    @Override
    protected boolean processConsoleLine(String line) {
        return true;
    }
}

package org.spiderwiz.tutorial.lesson12.archiver;

import org.spiderwiz.tutorial.objectLib.ChatMessage;
import org.spiderwiz.zutils.ZDate;

/**
 * Implementation class of ChatMessagee for the archiver.
 */
public class ChatMessageArchiver extends ChatMessage {

    /**
     * Every arriving message is encapsulated in ArchivedChatItem and archived.
     * @return true
     */
    @Override
    protected boolean onEvent() {
        try {
            ArchivedChatItem item =
                ArchiverMain.createTopLevelObject(ArchivedUser.class, getParent().getObjectID()).
                    createChild(ArchivedChatItem.class, null);
            item.archive(ZDate.now(), getParent().getParent().getParent().getObjectID(), getMessage());
        } catch (Exception ex) {
            ArchiverMain.getInstance().sendExceptionMail(ex, "When trying to archive a chat item", null, false);
        }
        return true;
    }
}

package org.spiderwiz.tutorial.lesson12.chat;

import java.util.Map;
import java.util.UUID;
import org.spiderwiz.tutorial.objectLib.ChatApp;
import org.spiderwiz.tutorial.objectLib.ChatMessage;
import org.spiderwiz.tutorial.objectLib.ChatRoom;
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.
     * @return true to indicate that the event has been handled.
     */
    @Override
    protected boolean onEvent() {
        if (ChatMain.getInstance().isSameRoom(getParent().getParent().getParent().getObjectID())) {
            String name = ((Chatter)getParent()).getName();
            if (name == null)
                name = getParent().getObjectID();
            System.out.printf("%1$s: %2$sn", name, getMessage());
        }
        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, or:
     *      3. applications whose 'appParams' contains the mapping 'role'->'admin'
     * @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) && (
                isMemberOfMyRoom(appUUID) || appParams != null && "admin".equals(appParams.get("role"))
            );
    }

    /**
     * Check if the user running the application whose UUID is given is on the same room as this message is sent to.
     * @param appUUID   Application UUID to check
     * @return  true if the application is in the same room as us.
     */
    private boolean isMemberOfMyRoom(UUID appUUID) {
        try {
            // The room is the great-grandparent of the message
            ChatRoom chatRoom = (ChatRoom)getParent().getParent().getParent();
            return chatRoom.getChild(ChatApp.class, appUUID.toString()) != null;
        } catch (NoSuchFieldException | IllegalAccessException ex) {
            // Arriving here if a ChatApp does not contain ObjectCode static field or the field is not public.
            // In this case, send a command exception message.
            ChatMain.getInstance().sendExceptionMail(ex, "Cannot instantiate ChatApp", null, false);
            return false;
        }
    }
    
}

[application name]Chat 1
[log folder]/tests/Chat1/Logs
[backup folder]/tests/Chat1/Backup
[history file]/tests/Chat1/history.dat
[producer-1]websocket=localhost:90/MyHub

[application name]Chat 2
[log folder]/tests/Chat2/Logs
[backup folder]/tests/Chat2/Backup
[history file]/tests/Chat2/history.dat
[producer-1]websocket=localhost:90/MyHub

[application name]Chat 3
[log folder]/tests/Chat3/Logs
[backup folder]/tests/Chat3/Backup
[history file]/tests/Chat3/history.dat
[producer-1]websocket=localhost:90/MyHub