syncmanager.java

First of all, the Applet-phone is a SIP User-Agent with audio and text messaging capabilities. But

                boolean locationConstraintRes=checkLocationConstraint(locationConstraint.name,
                receiverBadge.getIdentifier() );
                if (locationConstraintRes) {
                    GatewayDebug.println("SyncManager, we lock the manager, checkConstraints(), "+
                    "the receiver "+
                    "badge is present in a location who belongs to his constraints: "+
                    "STATUS FAILED_ON_LOCATION");
                    return Constraint.FAILED_ON_LOCATION;
                }
            }
        }
        
        return Constraint.SUCCESS;    
    }
    
/***********************************************************************************/    
/************************* PRIVATE METHODS ******************************************/    
/***********************************************************************************/  
        
       
    
/******************************** BADGES LIST ************************************/    
    
    private Badge getBadgeFromIdentifier(String identifier) {
        for (int i=0;i<presenceServer.badgesList.size();i++) {
            Badge badge=(Badge)presenceServer.badgesList.elementAt(i);
            if (badge.getIdentifier().compareToIgnoreCase(identifier) ==0) {
                return badge;
            }
        }
        return null;
    }
    
    private void addBadge(Badge badge) {
        presenceServer.badgesList.addElement(badge);
    }
    
    private void removeBadge(Badge badge) {
        presenceServer.badgesList.removeElement(badge);
    }
    
    private boolean hasBadge(String uri) {
        for (int j=0;j<presenceServer.badgesList.size();j++) {
              Badge badge=(Badge)presenceServer.badgesList.elementAt(j);
              GatewayDebug.println("SyncManager, hasBadge(), badge.getURI():"+
              badge.getURI());
              GatewayDebug.println("SyncManager,  hasBadge(), uri:"+uri);
              if (badge.getURI().equals(uri)) return true;
        }
        return false; 
    }
    
    private  Badge getBadgeFromURI(String uri) {
        for (int j=0;j<presenceServer.badgesList.size();j++) {
              Badge badge=(Badge)presenceServer.badgesList.elementAt(j);
              if (badge.getURI().equals(uri)) return badge;
        }
        return null; 
    }
    
    private boolean hasSenderBadge(Request request) {
        // Get the From header and check if the sip URI belongs to a badge:
        FromHeader fromHeader=(FromHeader)request.getHeader(FromHeader.NAME);
        Address fromAddress=fromHeader.getAddress();
        javax.sip.address.URI uri=fromAddress.getURI();
        javax.sip.address.URI uriCleaned=GatewayUtilities.getCleanUri(uri);
        return hasBadge(uriCleaned.toString());
    }
    
    private boolean hasReceiverBadge(Request request) {
        // Get the To headbadge.getURI()er and check if the sip URI belongs to a badge:
        ToHeader toHeader=(ToHeader)request.getHeader(ToHeader.NAME);
        Address toAddress=toHeader.getAddress();
        javax.sip.address.URI uri=toAddress.getURI();
        javax.sip.address.URI uriCleaned=GatewayUtilities.getCleanUri(uri);
        return hasBadge(uriCleaned.toString());
    }
    
    private void write() {
        GatewayDebug.println("SyncManager, writing in the file");
        String res="<?xml version='1.0' encoding='us-ascii'?>\n"+
                   "<badges>\n";
        for (int j=0;j<presenceServer.badgesList.size();j++) {
              Badge badge=(Badge)presenceServer.badgesList.elementAt(j);
              res+=badge.toXMLTag();
        }
        res+="</badges>\n";
        
        GatewayUtilities.writeToFile(presenceServer.badgesFile,res); 
   }
   
/******************************** BASES LIST ************************************/
    
    private boolean hasBase(Base b) {
        Collection c=presenceServer.basesList.values();        
        Iterator it=c.iterator();
        //for (int i=0;i<presenceServer.basesList.size();i++) {
            //Base base=(Base)presenceServer.basesList.elementAt(i);
        while(it.hasNext()){
            Base base=(Base)it.next();
            if (base.getIdentifier().compareToIgnoreCase(b.getIdentifier()) ==0)
                return true;
        }
        return false;
    }
    
    private void addBase(Base b) {
        presenceServer.basesList.put(b.getIdentifier(),b);//addElement(b);
    }
       
    private Base getBase(String baseReaderIdentifier) {
        Collection c=presenceServer.basesList.values();        
        Iterator it=c.iterator();
        //for (int i=0;i<presenceServer.basesList.size();i++) {
            //Base base=(Base)presenceServer.basesList.elementAt(i);
        while(it.hasNext()){
            Base base=(Base)it.next();
            if (base.getIdentifier().compareToIgnoreCase(baseReaderIdentifier) ==0)
                return base;
        }
        return null;
    }
  
/******************************* BADGES LIST TABLE  *********************************/  
   
    private void displayBadgesListTable(Vector badgesList) {
        /*BadgesListTable badgesListTable=gatewayGUI.gatewayListener.badgesListFrame.
        getBadgesListTable();
        // first, let's clean:
        badgesListTable.removeAllRows();*/
        //Vector badgesList=presenceServer.getBadgesList();
        System.out.println("/*******************************************/");
        System.out.println("/*******Bagdes List ************/");        
        for (int i=0;i<badgesList.size();i++) {
            Badge badge=(Badge)badgesList.elementAt(i);
            /*Object[] newRow=new Object[4];
            newRow[0]=badge.getOwner();
            newRow[1]=badge.getIdentifier();
            newRow[2]=badge.getRank();
            newRow[3]=badge.getURI();*/
            System.out.println(badge.getOwner()+" "+badge.getIdentifier()+" "+badge.getRank()+" "+badge.getURI());
            //badgesListTable.df.addRow(newRow);
        }
        System.out.println("/*******************************************/");
    }
    

/******************************* BADGES TABLE  *********************************************/  
    
    private void addBadgesTable(Vector badgesList,String location,String baseReaderIdentifier) {
        GatewayDebug.println("SyncManager, addBadges(), we add all GUI badges ("+badgesList.size()+
        ") for"+
        " the base: "+baseReaderIdentifier);
        Map bases=presenceServer.getBasesList();
        Base base=(Base)bases.get(baseReaderIdentifier);
        Vector badges=base.getCurrentBadges();
        badges.addAll(badgesList);
        //gatewayGUI.badgesTable.addBadges(badgesList,location,baseReaderIdentifier);
    }
    
    private void removeBadgesTableFromBase(String baseReaderIdentifier) {
        Map bases=presenceServer.getBasesList();
        Base base=(Base)bases.get(baseReaderIdentifier);
        Vector badges=base.getCurrentBadges();        
        badges.removeAllElements();
    }
    
    private boolean hasBadgeInBadgeTable(Badge badge) {
        Map bases=presenceServer.getBasesList();
        Collection basesList=bases.values();
        Iterator it=basesList.iterator();
        while(it.hasNext()){
            Base base=(Base)it.next();
            Vector badges=base.getCurrentBadges();
            for(int i=0;i<badges.size();i++){
                Badge badj=(Badge)badges.elementAt(i);
                if(badj.getIdentifier().equals(badge.getIdentifier()))
                    return true;
            }
        }
        //return  gatewayGUI.badgesTable.hasBadge(badge);
        return false;
    }
    
    private Location getBadgeLocationInBadgeTable(Badge badge) {
        Map bases=presenceServer.getBasesList();
        Collection basesList=bases.values();
        Iterator it=basesList.iterator();
        while(it.hasNext()){
            Base base=(Base)it.next();
            Vector badges=base.getCurrentBadges();
            for(int i=0;i<badges.size();i++){
                Badge badj=(Badge)badges.elementAt(i);
                if(badj.getIdentifier().equals(badge.getIdentifier()))
                    return new Location(base.getLocation());
            }
        }
        return null;
    }
    
    private boolean checkRankConstraint(String rank,String locationName,String receiverBadgeIdentifier){
         //return  gatewayGUI.badgesTable.checkRankConstraint(rank,locationName,receiverBadgeIdentifier); 
        Map bases=presenceServer.getBasesList();
        Collection basesList=bases.values();
        Iterator it=basesList.iterator();
        while(it.hasNext()){
            Base base=(Base)it.next();
            Vector badges=base.getCurrentBadges();
            for(int i=0;i<badges.size();i++){
                Badge badge=(Badge)badges.elementAt(i);
                String badgeIdentifierField=badge.getIdentifier();
                String badgeLocationField=base.getLocation();
                String badgeRankField=badge.getRank();
                if ( badgeIdentifierField!=null && !badgeIdentifierField.equals(receiverBadgeIdentifier)) {
                   if (badgeRankField!=null && badgeRankField.equals(rank)) {
                        if (badgeLocationField!=null && badgeLocationField.equals(locationName)) {
                            return true;
                        }
                   }
                }
            }
       }
       return false;
    }
    
    private boolean checkPeopleConstraint(String name,String locationName,String receiverBadgeIdentifier){
        // return  gatewayGUI.badgesTable.checkPeopleConstraint(name,locationName,receiverBadgeIdentifier); 
        Map bases=presenceServer.getBasesList();
        Collection basesList=bases.values();
        Iterator it=basesList.iterator();
        while(it.hasNext()){
            Base base=(Base)it.next();
            Vector badges=base.getCurrentBadges();
            for(int i=0;i<badges.size();i++){
                Badge badge=(Badge)badges.elementAt(i);
                String badgeIdentifierField=badge.getIdentifier();
                String badgeLocationField=base.getLocation();                                
                String badgeOwnerField=badge.getOwner();
                if ( badgeIdentifierField!=null && !badgeIdentifierField.equals(receiverBadgeIdentifier)) {
                    GatewayDebug.println("badgeOwnerField:"+badgeOwnerField);
                    GatewayDebug.println("name:"+name);
                    if (badgeOwnerField!=null && badgeOwnerField.equals(name)) {
                        if (badgeLocationField!=null && badgeLocationField.equals(locationName)) {
                            return true;
                        }
                    }
                }
            }
       }
       return false;
    }
    
    private boolean checkLocationConstraint(String locationConstraintName,String receiverBadgeIdentifier){
         //return  gatewayGUI.badgesTable.checkLocationConstraint(name,receiverBadgeIdentifier); 
        Map bases=presenceServer.getBasesList();
        Collection basesList=bases.values();
        Iterator it=basesList.iterator();
        while(it.hasNext()){
            Base base=(Base)it.next();
            Vector badges=base.getCurrentBadges();
            for(int i=0;i<badges.size();i++){
                Badge badge=(Badge)badges.elementAt(i);
                String badgeIdentifierField=badge.getIdentifier();
                String badgeLocationField=base.getLocation();                
                if ( badgeIdentifierField!=null && badgeIdentifierField.equals(receiverBadgeIdentifier)) {
                   GatewayDebug.println("locationConstraintName:"+locationConstraintName);
                   GatewayDebug.println("badgeLocationField:"+ badgeLocationField);
                   if (badgeLocationField!=null && badgeLocationField.equals(locationConstraintName)) {
                           return true;
                   }
                }
            }
        }
        return false;
    }
   
}