calendarmodelimpl.java

Rapla是一个灵活的多用户资源管理系统。它提供的一些功能有：日历GUI

                }
            }

        }

        return result;
    }


    /* (non-Javadoc)
	 * @see org.rapla.calendarview.CalendarModel#setSelectedObjects(java.util.List)
	 */
    public void setSelectedObjects(Collection selectedObjects) {
        this.selectedObjects = retainRaplaObjects(selectedObjects);
    }

    private List retainRaplaObjects(Collection list ){
        List result = new ArrayList();
        for ( Iterator it = list.iterator();it.hasNext();) {
            Object obj = it.next();
            if ( obj instanceof RaplaObject) {
                result.add( obj );
            }
        }
        return result;
    }



    public Collection getSelectedObjects()
    {
        return selectedObjects;
    }

    /* (non-Javadoc)
	 * @see org.rapla.calendarview.CalendarModel#getFilter()
	 */
    public ClassificationFilter[] getFilter() {
        return filter;
    }

    public Object clone()  {
        CalendarModelImpl clone;
        try
        {
            clone = (CalendarModelImpl )super.clone();
        }
        catch ( CloneNotSupportedException e )
        {
            throw new IllegalStateException( e.getMessage() );
        }
        return clone;
    }

    /* (non-Javadoc)
	 * @see org.rapla.calendarview.CalendarModel#getReservations(java.util.Date, java.util.Date)
	 */
    public Reservation[] getReservations() throws RaplaException {
        return getReservations( getStartDate(), getEndDate() );
    }

    public Reservation[] getReservations(Date startDate, Date endDate) throws RaplaException {
        return (Reservation[]) getReservationsAsList( startDate, endDate ).toArray( Reservation.RESERVATION_ARRAY);
    }

    private boolean hasAllocatedOne( Reservation reservation,Allocatable[] allocatables ) {
        for (int j=0;j<allocatables.length;j++) {
            Allocatable allocatable = allocatables[j];
            if (reservation.hasAllocated( allocatable)) {
               return true;
            }
        }
        return false;
    }

    private boolean hasConflict( Reservation reservation,Conflict[] conflict ) {
        for (int j=0;j<conflict.length;j++) {
            Conflict allocatable = conflict[j];
            if (reservation.equals( allocatable.getReservation1() ) || reservation.equals( allocatable.getReservation2())) {
               return true;
            }
        }
        return false;
    }

    private void restrict(Collection reservations,Allocatable[] allocatables) throws RaplaException {
        for ( Iterator it = reservations.iterator();it.hasNext();) {
            Reservation event = (Reservation)it.next();
            if ( !hasAllocatedOne( event, allocatables) ) {
                it.remove();
            }
        }
    }

    private void restrict(Collection reservations,User[] users) throws RaplaException {
        HashSet usersSet = new HashSet(Arrays.asList(users));
        for ( Iterator it = reservations.iterator();it.hasNext();) {
            Reservation event = (Reservation)it.next();
            if ( !usersSet.contains( event.getOwner() )) {
                it.remove();
            }
        }
    }

    private void restrict(Collection reservations,Conflict[] conflicts) throws RaplaException {
        for ( Iterator it = reservations.iterator();it.hasNext();) {
            Reservation event = (Reservation)it.next();
            if ( !hasConflict( event, conflicts )) {
                it.remove();
            }
        }
    }

    private void restrictReservationTypes(Collection reservations,Set reservationTypes) throws RaplaException {
        for ( Iterator it = reservations.iterator();it.hasNext();) {
            Reservation event = (Reservation)it.next();
            if ( !reservationTypes.contains( event.getClassification().getType() )) {
                it.remove();
            }
        }
    }


    private Collection getRestrictedReservations( Date start, Date end) throws RaplaException {
    	Collection selectedReservations = getSelected( Reservation.TYPE);
        if ( selectedReservations.size() > 0) {
            return selectedReservations;
        }
        Reservation[] reservations =m_facade.getReservations(null, start, end,getFilter() );
        return Arrays.asList( reservations );

    }

    private List getReservationsAsList(Date start, Date end) throws RaplaException {
        
        List reservations = new ArrayList(getRestrictedReservations( start, end));
        Set reservationTypes = getSelectedTypes( DynamicTypeAnnotations.VALUE_RESERVATION_CLASSIFICATION);
        if ( reservationTypes.size() > 0 ) {
            restrictReservationTypes( reservations, reservationTypes);
        }
        Allocatable[] allocatables = getSelectedAllocatables();
        if ( allocatables.length> 0) {
            restrict( reservations, allocatables );
        }
        User[] users = getSelectedUsers();
        if ( users.length> 0) {
            restrict( reservations, users );
        }
        Conflict[] conflicts = getSelectedConflicts();
        if ( conflicts.length > 0) {
            restrict( reservations, conflicts );
        }

        /*
        if ( isListingAllocatables()) {
            reservationList = new ArrayList( );
        } else if ( Period.TYPE.equals(getSelectionType())) {
            Iterator it = getSelectedObjects(  ).iterator();
            while (it.hasNext()) {
                Period period = (Period) it.next();
                reservationList.addAll( Arrays.asList(  m_facade.getReservations(null,period.getStart() , period.getEnd(), null) ));
            }
        } else if ( User.TYPE.equals( getSelectionType()) ) {
            Iterator it = getSelectedObjects( ).iterator();
            while (it.hasNext()) {
                User user = (User) it.next();
                reservationList.addAll( Arrays.asList(  m_facade.getReservations(user, start , end, null) ));
            }
        } else if ( isListingConflicts() ) {
            reservationList = new ArrayList( getReservationsForAllocatables( getSelectedAllocatables(), start, end ));
        }*/
        return reservations;
    }

    /* (non-Javadoc)
	 * @see org.rapla.calendarview.CalendarModel#getAllocatables()
	 */
    public Allocatable[] getSelectedAllocatables() throws RaplaException {
        Collection result = new HashSet();
        Iterator it = getSelectedObjectsAndChildren().iterator();
        while (it.hasNext()) {
            RaplaObject object  = (RaplaObject) it.next();
            if ( object.getRaplaType().equals( Allocatable.TYPE )) {
                result.add( object  );
            }
            if ( object.getRaplaType().equals( Conflict.TYPE )) {
                result.add( ((Conflict)object).getAllocatable() );
            }
        }
         return (Allocatable[]) result.toArray(Allocatable.ALLOCATABLE_ARRAY);
   }

    public User[] getSelectedUsers()  {
        return (User[]) getSelected(User.TYPE).toArray(User.USER_ARRAY);
   }

    public Conflict[] getSelectedConflicts()  throws RaplaException {
        return (Conflict[]) getSelected(Conflict.TYPE).toArray(Conflict.CONFLICT_ARRAY);
   }

    public Set getSelectedTypes(String classificationType) throws RaplaException {
        Set result = new HashSet();
        Iterator it = getSelectedObjectsAndChildren().iterator();
        while (it.hasNext()) {
            RaplaObject object  = (RaplaObject) it.next();
            if ( object.getRaplaType().equals( DynamicType.TYPE )) {
                if (classificationType == null || (( DynamicType) object).getAnnotation( DynamicTypeAnnotations.KEY_CLASSIFICATION_TYPE).equals( classificationType))
                {
                    result.add( object  );
                }
            }
        }
         return result;
   }
    
    public Set getSelected(RaplaType type)  {
        Set result = new HashSet();
        Iterator it = getSelectedObjects().iterator();
        while (it.hasNext()) {
            RaplaObject object  = (RaplaObject) it.next();
            if ( object.getRaplaType().equals( type )) {
                result.add( object  );
            }
        }
         return result;
   }

    public Date[] getConflictDates() throws RaplaException {
        ArrayList list = new ArrayList();
        Conflict[] conflicts = getSelectedConflicts();
        for ( int i=0;i<conflicts.length;i++)
        {
            Date start = getFirstConflictDate( conflicts[i]);
            if ( start != null)
            {
                list.add( start );
            }
        }
        Collections.sort( list );
        return (Date[]) list.toArray( new Date[]{});
    }

    public Date getFirstConflictDate(Conflict conflict) throws RaplaException {
        Appointment a1  =conflict.getAppointment1();
        Appointment a2  =conflict.getAppointment2();
        Date minEnd =  a1.getMaxEnd();
        if ( a1.getMaxEnd() != null && a2.getMaxEnd() != null && a2.getMaxEnd().before( a1.getMaxEnd())) {
            minEnd = a2.getMaxEnd();
        }
        Date maxStart = a1.getStart();
        if ( a2.getStart().after( a1.getStart())) {
            maxStart = a2.getStart();
        }
        // Jetzt berechnen wir fuer 2 Jahre
        if ( minEnd == null)
            minEnd = new Date(maxStart.getTime() + DateTools.MILLISECONDS_PER_WEEK * 100);

        AppointmentBlockArray listA = new AppointmentBlockArray();
        a1.createBlocks(maxStart, minEnd, listA );
        AppointmentBlockArray listB = new AppointmentBlockArray();
        a2.createBlocks( maxStart, minEnd, listB );
        for ( int i=0, j=0;i<listA.size() && j<listB.size();) {
            long s1 = listA.getStartAt( i);
            long s2 = listB.getStartAt( j);
            long e1 = listA.getEndAt( i);
            long e2 = listB.getEndAt( j);
            if ( s1< e2 && s2 < e1) {
                return new Date( Math.max( s1, s2));
            }
            if ( s1> s2)
               j++;
            else
               i++;
        }
        return null;
    }

    protected I18nBundle getI18n() {
        return i18n;
    }

    protected RaplaLocale getRaplaLocale() {
        return raplaLocale;
    }

    public boolean isOnlyCurrentUserSelected() {
        User[] users = getSelectedUsers();
        User currentUser = getUser();
        return ( users.length == 1 && users[0].equals( currentUser));
    }

    public void selectUser(User user) {
        for (Iterator it = selectedObjects.iterator();it.hasNext();) {
            RaplaObject obj =(RaplaObject) it.next();
            if (obj.getRaplaType().equals( User.TYPE) ) {
                it.remove();
            }
        }
        if ( user != null)
        {
            selectedObjects.add( user );
        }
    }

    public Object getOption( String name )
    {
        return optionMap.get(  name );
    }

    public void setOption( String name, RaplaObject object )
    {
        optionMap.put( name, object);
    }

    public void setOption( String name, String string )
    {
        optionMap.put( name, string);
    }

 
}