[Magicmap-commits] magicmapserver/src/net/sf/magicmap/server/calculation CalculationManager.java,NONE,1.1.2.1 Calculation.java,NONE,1.1.2.1

[Andreas W. <an...@us...>]

Update of /cvsroot/magicmap/magicmapserver/src/net/sf/magicmap/server/calculation
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv23010/src/net/sf/magicmap/server/calculation

Added Files:
      Tag: ServerCalculationBranch
	CalculationManager.java Calculation.java 
Log Message:
First Version

--- NEW FILE: CalculationManager.java ---
package net.sf.magicmap.server.calculation;

import java.util.HashMap;

import net.sf.magicmap.server.model.node.NodeModel;

public class CalculationManager {
	
	private HashMap<String,NodeModel>

}

--- NEW FILE: Calculation.java ---
package net.sf.magicmap.server.calculation;

import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;

import javax.swing.SwingUtilities;

import net.sf.magicmap.server.dto.AccessPointDTO;
import net.sf.magicmap.server.dto.ClientDTO;
import net.sf.magicmap.server.dto.PositionDTO;
import net.sf.magicmap.server.dto.SignalCharacterDTO;
import net.sf.magicmap.server.dto.SimpleScanResultDTO;
import net.sf.magicmap.server.interfaces.CalculationInterface;
import net.sf.magicmap.server.model.node.AccessPointNode;
import net.sf.magicmap.server.model.node.ClientNode;
import net.sf.magicmap.server.model.node.LocationNode;
import net.sf.magicmap.server.model.node.Node;
import net.sf.magicmap.server.model.node.NodeModel;

public class Calculation implements CalculationInterface {

	public void positionCreatedOrUpdatedOrDeleted(String mapName, PositionDTO position) {
		try{
		      SwingUtilities.invokeAndWait(new Runnable() {

		        public void run(){
		          try{
		            NodeModel nodeModel = controller.getNodeModel();
		     
		            Node node = nodeModel.findNode(position.getName());

		            if (position.isDeleted()){

		              if (position.getClient() == null && position.getAccessPoint() == null){
		                if (node != null){
		                  // Referenzpunkt wird gelöscht
		                  if (node.getType() == NodeModel.NODETYPE_LOCATION){
		                    // Aus dem lokalen Graphen entfernen das Ding
		                    nodeModel.removeNode(node);
		                  } else{
		                    System.out
		                        .println("Position with location information deleted, but node with given name is not a location!");
		                  }
		                } else{
		                  System.out.println("Position with location information deleted, but no node found for it.");
		                }
		                return;
		              }
		              if (position.getClient() != null){
		                Node client = nodeModel.findNode(position.getClient().getName());
		                /*
		                 if (client != null) {
		                 // Client wurde "frei" gemacht
		                 if (client.getType() == NodeModel.NODETYPE_CLIENT) {
		                 client.setFix(false);
		                 System.out.println("Client unfixed.");
		                 } else {
		                 System.out.println("Position with client deleted, but node with given name is not a client!");
		                 }
		                 } else {
		                 System.out.println("Position with client deleted, but no node found for it.");
		                 }*/
		                return;
		              }
		              if (position.getAccessPoint() != null){
		                AccessPointNode ap = nodeModel.findAccessPoint(position.getAccessPoint().getMac());
		                if (ap != null){
		                  // AccessPoint wurde "frei" gemacht
		                  ap.setFix(false);
		                  System.out.println("Accesspoint unfixed.");
		                } else{
		                  System.out.println("Position with accesspoint deleted, but no node found for it.");
		                }
		                return;
		              }

		              System.out.println("Position with id " + position.getId().longValue() + " was deleted but not handled.");
		              return;
		            } else{
		              // Neues Positionsobjekt oder altes wurde aktualisiert (Location)
		              if (position.getClient() == null && position.getAccessPoint() == null){
		                // Referenzpunkt angelegt oder aktualisiert
		                LocationNode location;
		                if (node == null){
		                  // Referenzpunkt bisher unbekannt
		                  location = new LocationNode(nodeModel);

		                  location.setId(position.getId().longValue());
		                  location.setName(position.getName());
		                  nodeModel.addNode(location);
		                  if (position.getPosX().intValue() != -1 && position.getPosY().intValue() != -1){
		                      location.setPosition(position.getPosX().intValue(), position.getPosY().intValue());
		                      location.setFix(true);
		                    } else{
		                      location.setFix(false);
		                    }
		                  // Signalcharakteristik auswerden und gesehene
		                  // AccessPoints ebenfalls erzeugen bzw. mit ihnen Verbindungen
		                  // herstellen
		                  SignalCharacterDTO sc = position.getCharacter();
		                  SimpleScanResultDTO[] sr = sc.getSimpleScanResults();
		                  for (int i = 0; i < sr.length; i++){
		                    SimpleScanResultDTO r = sr[i];
		                    String mac = r.getMacAP();
		                    // Gibt es ggf. einen AP mit der Mac-Adresse?
		                    AccessPointNode ap = nodeModel.findAccessPoint(mac);
		                    if (ap == null){
		                      // Nein
		                      ap = new AccessPointNode(nodeModel);
		                      ap.setMacAddress(mac);
		                      nodeModel.addNode(ap);
		                      //ap.setName(mac);
		                    }
		                    location.seesAccessPoint(ap, r.getSignalLevel().doubleValue());
		                  }
		                } else{
		                  System.out.println("Referenzpunkt verschoben.");
		                  // Referenzpunkt wird nur aktualisiert, wir gehen davon aus
		                  // das sich nur die Position verändern darf (die Programmlogik sieht
		                  // es jedenfalls so vor, Ändern der APs geschieht über Löschen und
		                  // Neuanlegen)
		                  location = (LocationNode) node;
		                  location.setId(position.getId().longValue()); // Falls nicht gesetzt
		                  // Nur Position von fixierten Orten/Referenzpunkten beachten
		                  if (position.isFixed()){
		                    location.setPosition(position.getPosX().intValue(), position.getPosY().intValue());
		                    location.setFix(true);
		                  } else{
		                    location.setFix(false);
		                  }
		                  // Signalcharakteristik auswerden und gesehene
		                  // AccessPoints ebenfalls erzeugen bzw. mit ihnen Verbindungen
		                  // herstellen
		                  SignalCharacterDTO sc = position.getCharacter();
		                  SimpleScanResultDTO[] sr = sc.getSimpleScanResults();
		                  // Alle momentan gesehenen AccessPoints merken

		                  ArrayList seenAps = location.getSeenAccessPoints();
		                  for (int i = 0; i < sr.length; i++){
		                    SimpleScanResultDTO r = sr[i];
		                    String mac = r.getMacAP();
		                    // Gibt es ggf. einen AP mit der Mac-Adresse?
		                    AccessPointNode ap = nodeModel.findAccessPoint(mac);
		                    if (ap == null){
		                      // Nein
		                      ap = new AccessPointNode(nodeModel);
		                      ap.setMacAddress(mac);
		                      nodeModel.addNode(ap);
		                      //ap.setName(mac);
		                    } else{
		                      // AccessPoint nur aktualisieren?
		                      if (seenAps.remove(ap)){
		                        // Nur Signallevel aktualisieren
		                        location.setSignalLevelForAcessPoint(ap, r.getSignalLevel().doubleValue());
		                      } else{
		                        // Neu
		                        location.seesAccessPoint(ap, r.getSignalLevel().doubleValue());
		                      }
		                    }
		                  }

		                  // Alle APs aus seenAps werden demzufolge nicht mehr gesehen und
		                  // dies teilen wir unserem Modell mit
		                  for (int i = 0; i < seenAps.size(); i++){
		                    AccessPointNode ap = (AccessPointNode) seenAps.get(i);
		                    location.notSeesAccessPoint(ap);
		                  }

		                }

		                return;
		              }
		              if (position.getAccessPoint() != null){
		                System.out.println("Accesspointposition erzeugt oder aktualisiert.");
		                AccessPointDTO apdto = position.getAccessPoint();
		                AccessPointNode ap = nodeModel.findAccessPoint(apdto.getMac());
		                if (ap == null){
		                  // Gibt es noch nicht in unserem Modell => Schnell erzeugen
		                  ap = new AccessPointNode(nodeModel);
		                  ap.setMacAddress(apdto.getMac());
		                  nodeModel.addNode(ap);
		                }
		                ap.setId(position.getId().longValue());
		                
		                // Nur Position von fixierten AccessPoints beachten
		                if (position.isFixed()){
		                  // AccessPoint wurde fixiert
		                  ap.setPosition(position.getPosX().intValue(), position.getPosY().intValue());
		                  ap.setFix(true);
		                } else{
		                  // Loser AccessPoint gemeldet
		                  ap.setFix(false);
		                  System.out.println("Unfix accesspoint received. This was not in our contract.");
		                }
		                return;
		              }
		              if (position.getClient() != null && position.getCharacter() != null){
		                //System.out.println("Clientposition erzeugt oder aktualisiert für Client " + position.getClient().getName());
		                ClientDTO clientdto = position.getClient();
		                ClientNode client = (ClientNode) nodeModel.findNode(clientdto.getName());

		                // Wenn eigener Client unfixiert kommt Positionsangaben ignorieren
		                if (client == controller.getClient() && !position.isFixed()){
		                  // Aber noch schnell unfixieren
		                  client.setFix(false);
		                  System.out.println("Eigener Client wird ignoriert");
		                  return;
		                } else{
		                  if (client == controller.getClient() && position.isFixed()){
		                    System.out.println("Eigener Client empfangen mit fixierter Position.");
		                  }
		                }

		                // Sonst beachten wir alle Positionen die wir bekommen
		                if (client == null){
		                  System.out.println("Neuer Client empfangen (" + clientdto.getMac() + ", " + clientdto.getName()
		                      + ". Füge zum Graphen hinzu.");
		                  client = new ClientNode(nodeModel);
		                  client.setMacAddress(clientdto.getMac());
		                  client.setName(clientdto.getName());
		                  nodeModel.addNode(client);
		                }

		                System.out.println("Position für Client " + client.getName() + " empfangen. fix = "
		                    + position.isFixed());
		                //client.setPosition(position.getPosX().intValue(), position.getPosY().intValue());

		                if (position.isFixed()){
		                  // Client wurde fixiert
		                  client.setFix(true);
		                  client.setPosition(position.getPosX().intValue(), position.getPosY().intValue());
		                } else{
		                  client.setFix(false);
		                }
		                client.setId(position.getId().longValue());

		                // Signalstärken usw. verwaltet der scannende Client selbst
		                if (client == controller.getClient()) return;

		                // Signalcharakteristik auswerden und gesehene
		                // AccessPoints ebenfalls erzeugen bzw. mit ihnen Verbindungen
		                // herstellen
		                SignalCharacterDTO sc = position.getCharacter();
		                SimpleScanResultDTO[] sr = sc.getSimpleScanResults();
		                // Alle momentan gesehenen AccessPoints merken
		                ArrayList seenAps = client.getSeenAccessPoints();

		                if (sr != null){

		                  for (int i = 0; i < sr.length; i++){
		                    SimpleScanResultDTO r = sr[i];
		                    String mac = r.getMacAP();
		                    // Gibt es ggf. einen AP mit der Mac-Adresse?
		                    AccessPointNode ap = nodeModel.findAccessPoint(mac);
		                    if (ap == null){
		                      // Nein
		                      ap = new AccessPointNode(nodeModel);
		                      ap.setMacAddress(mac);
		                      nodeModel.addNode(ap);
		                      //ap.setName(mac);
		                    } else{
		                      // AccessPoint nur aktualisieren?
		                      if (seenAps.remove(ap)){
		                        // Nur Signallevel aktualisieren
		                        client.setSignalLevelForAcessPoint(ap, r.getSignalLevel().doubleValue());
		                      } else{
		                        // Neu
		                        client.seesAccessPoint(ap, r.getSignalLevel().doubleValue());
		                      }
		                    }
		                  }

		                }

		                // Alle APs aus seenAps werden demzufolge nicht mehr gesehen und
		                // dies teilen wir unserem Modell mit
		                for (int i = 0; i < seenAps.size(); i++){
		                  AccessPointNode ap = (AccessPointNode) seenAps.get(i);
		                  client.notSeesAccessPoint(ap);
		                }
		                return;
		              }
		            }
		            System.out.println("Unbekannte Position. Kann nix anfangen damit.");
		          } catch (Exception e){
		            e.printStackTrace();
		          }
		        }
		      });
		    } catch (InterruptedException e){
		      // TODO Auto-generated catch block
		      e.printStackTrace();
		    } catch (InvocationTargetException e){
		      // TODO Auto-generated catch block
		      e.printStackTrace();
		    }
	}

	public PositionDTO[] getPositions(String mapName) {
		// TODO Auto-generated method stub
		return null;
	}

}