eventutility.java

开源项目CRM之OpenCustomer

package org.opencustomer.application.db.util;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;

import org.apache.log4j.Logger;
import org.opencustomer.application.db.vo.calendar.EventVO;
import org.opencustomer.application.db.vo.calendar.EventVO.RecurrenceInWeek;
import org.opencustomer.application.web.module.calendar.view.CalendarView;
import org.opencustomer.application.web.module.calendar.view.EventBean;

public final class EventUtility
{
    private static final Logger log = Logger.getLogger(CalendarView.class);
    
    public static Date calculateRecurrenceEndDate(EventVO event) 
    {
        Date recurrenceEndDate = event.getStartDate();
        
        if(!EventVO.RecurrenceType.NONE.equals(event.getRecurrenceType()) &&
                !EventVO.RecurrenceType.FOREVER.equals(event.getRecurrenceType()))
        {
            List<EventBean> beans = calculateRecurrences(null, event);
            for(EventBean bean : beans)
            {
                if(bean.getEndDate().after(recurrenceEndDate))
                    recurrenceEndDate = bean.getEndDate();
            }
        }
        else
            recurrenceEndDate = null;

        return recurrenceEndDate;
    }
    
    public static List<EventBean> calculateRecurrences(Date endDate, EventVO event)
    {
        List<EventBean> list = new ArrayList<EventBean>();
     
        int duration = (int)(event.getEndDate().getTime()-event.getStartDate().getTime());
        
        Calendar calcDate = GregorianCalendar.getInstance();
        calcDate.setTime(event.getStartDate());
        
        int step = event.getRecurrenceCycle();

        // handle days
        if(EventVO.RecurrenceUnit.DAY.equals(event.getRecurrenceCycleUnit()))
        {
            if(EventVO.RecurrenceType.NUMBER_OF_TIMES.equals(event.getRecurrenceType()))
            {
                for(int i=1; i<event.getRecurrenceNumberOfTimes(); i++)
                {
                    calcDate.add(Calendar.DAY_OF_MONTH, step);
                    list.add(new EventBean(calcDate.getTime(), duration, list.size()+1, event));
                }
            }
            else
            {
                Date calcEndDate = endDate;
                if(EventVO.RecurrenceType.UNTIL_DATE.equals(event.getRecurrenceType()))
                    calcEndDate = event.getRecurrenceUntilDate();
                
                boolean searching = true;
                while(searching) 
                {
                    calcDate.add(Calendar.DAY_OF_MONTH, step);
                    if(calcDate.getTime().before(calcEndDate))
                        list.add(new EventBean(calcDate.getTime(), duration, list.size()+1, event));
                    else
                        searching = false;
                        
                }
            }
        }
        else if(EventVO.RecurrenceUnit.WEEK.equals(event.getRecurrenceCycleUnit()))
        {
            int[] dayAdd = new int[event.getRecurrenceInWeek().size()];

            Calendar calcDateWeek = GregorianCalendar.getInstance();
            calcDateWeek.setTime(event.getStartDate());
            calcDateWeek.add(Calendar.DAY_OF_WEEK, 1);

            int pos = 0;
            for(int i=0; i<7; i++)
            {
                dayAdd[pos]++;
                if(event.getRecurrenceInWeek().contains(RecurrenceInWeek.getForDate(calcDateWeek.getTime())))
                    pos++;
                calcDateWeek.roll(Calendar.DAY_OF_WEEK, 1);
            }
            
            if(log.isDebugEnabled())
            {
               log.debug("dayAdds: "+dayAdd.length);
               for(int add : dayAdd)
                   log.debug("dayAdd="+add);
            }
            
            if(EventVO.RecurrenceType.NUMBER_OF_TIMES.equals(event.getRecurrenceType()))
            {
                int run = 0;
                for(int i=1; i<event.getRecurrenceNumberOfTimes(); i++)
                {                    
                    if(run < dayAdd.length)
                    {
                        calcDate.add(Calendar.DAY_OF_WEEK, dayAdd[run]);
                        run++;
                    }

                    if(run >= dayAdd.length)
                    {
                        if(step > 1) 
                            calcDate.add(Calendar.DAY_OF_WEEK, 7*(step-1));
                        run = 0;
                    }

                    list.add(new EventBean(calcDate.getTime(), duration, list.size()+1, event));
                }
            }
            else
            {
                Date calcEndDate = endDate;
                if(EventVO.RecurrenceType.UNTIL_DATE.equals(event.getRecurrenceType()))
                    calcEndDate = event.getRecurrenceUntilDate();
                
                int run = 0;
                boolean searching = true;
                while(searching) 
                {
                    if(run < dayAdd.length)
                    {
                        calcDate.add(Calendar.DAY_OF_WEEK, dayAdd[run]);
                        run++;
                    }

                    if(run >= dayAdd.length)
                    {
                        if(step > 1) 
                            calcDate.add(Calendar.DAY_OF_WEEK, 7*(step-1));
                        run = 0;
                    }

                    if(calcDate.getTime().before(calcEndDate))
                        list.add(new EventBean(calcDate.getTime(), duration, list.size()+1, event));
                    else
                        searching = false;
                        
                }
            }
        }
        else if(EventVO.RecurrenceUnit.MONTH.equals(event.getRecurrenceCycleUnit()))
        {
            if(EventVO.RecurrenceType.NUMBER_OF_TIMES.equals(event.getRecurrenceType()))
            {
                for(int i=1; i<event.getRecurrenceNumberOfTimes(); i++)
                {
                    if(EventVO.RecurrenceInMonth.DAY_OF_MONTH.equals(event.getRecurrenceInMonth()))
                        calcDate.add(Calendar.MONTH, step);
                    else
                    {                      
                        int dayOfWeek = calcDate.get(Calendar.DAY_OF_WEEK);
                        int dayOfWeekInMonth = calcDate.get(Calendar.DAY_OF_WEEK_IN_MONTH);
                        
                        calcDate.add(Calendar.MONTH, step);
                        
                        calcDate.set(Calendar.DAY_OF_WEEK, dayOfWeek);
                        calcDate.set(Calendar.DAY_OF_WEEK_IN_MONTH, dayOfWeekInMonth);
                    }
                    
                    list.add(new EventBean(calcDate.getTime(), duration, list.size()+1, event));
                }
            }
            else
            {
                Date calcEndDate = endDate;
                if(EventVO.RecurrenceType.UNTIL_DATE.equals(event.getRecurrenceType()))
                    calcEndDate = event.getRecurrenceUntilDate();
                
                boolean searching = true;
                while(searching) 
                {
                    if(EventVO.RecurrenceInMonth.DAY_OF_MONTH.equals(event.getRecurrenceInMonth()))
                        calcDate.add(Calendar.MONTH, step);
                    else
                    {                      
                        int dayOfWeek = calcDate.get(Calendar.DAY_OF_WEEK);
                        int dayOfWeekInMonth = calcDate.get(Calendar.DAY_OF_WEEK_IN_MONTH);
                        
                        calcDate.add(Calendar.MONTH, step);
                        
                        calcDate.set(Calendar.DAY_OF_WEEK, dayOfWeek);
                        calcDate.set(Calendar.DAY_OF_WEEK_IN_MONTH, dayOfWeekInMonth);
                    }
                    
                    if(calcDate.getTime().before(calcEndDate))
                        list.add(new EventBean(calcDate.getTime(), duration, list.size()+1, event));
                    else
                        searching = false;
                        
                }
            }
        }
        else if(EventVO.RecurrenceUnit.YEAR.equals(event.getRecurrenceCycleUnit()))
        {
            if(EventVO.RecurrenceType.NUMBER_OF_TIMES.equals(event.getRecurrenceType()))
            {
                for(int i=1; i<event.getRecurrenceNumberOfTimes(); i++)
                {
                    calcDate.add(Calendar.YEAR, step);
                    list.add(new EventBean(calcDate.getTime(), duration, list.size()+1, event));
                }
            }
            else
            {
                Date calcEndDate = endDate;
                if(EventVO.RecurrenceType.UNTIL_DATE.equals(event.getRecurrenceType()))
                    calcEndDate = event.getRecurrenceUntilDate();
                
                boolean searching = true;
                while(searching) 
                {
                    calcDate.add(Calendar.YEAR, step);
                    if(calcDate.getTime().before(calcEndDate))
                        list.add(new EventBean(calcDate.getTime(), duration, list.size()+1, event));
                    else
                        searching = false;
                        
                }
            }
        }
        
        if(log.isDebugEnabled()) 
        {
            for(EventBean bean : list)
            {
                log.debug("recurrence: "+bean);
            }
        }
        
        return list;
    }
}