ruby - कैलेंडर एप्लिकेशन में पुनरावर्ती घटनाओं को मॉडल करने का सबसे अच्छा तरीका क्या है?




algorithm calendar (12)

मैं एक समूह कैलेंडर एप्लिकेशन बना रहा हूं जिसे पुनरावर्ती घटनाओं का समर्थन करने की आवश्यकता है, लेकिन इन घटनाओं को संभालने के लिए मेरे द्वारा किए गए सभी समाधान एक हैक की तरह लगते हैं। मैं सीमित कर सकता हूं कि कोई कितना आगे देख सकता है, और फिर सभी घटनाओं को एक साथ उत्पन्न कर सकता है। या जब मैं कैलेंडर पर आगे दिखता हूं तो मैं घटनाओं को दोहराने और गतिशील रूप से प्रदर्शित कर सकता हूं, लेकिन अगर कोई घटना के किसी विशेष उदाहरण पर विवरण बदलना चाहता है तो मुझे उन्हें सामान्य ईवेंट में बदलना होगा।

मुझे यकीन है कि ऐसा करने का एक बेहतर तरीका है, लेकिन मुझे अभी तक यह नहीं मिला है। पुनरावर्ती घटनाओं को मॉडल करने का सबसे अच्छा तरीका क्या है, जहां आप विशेष ईवेंट उदाहरणों का विवरण बदल सकते हैं या हटा सकते हैं?

(मैं रुबी का उपयोग कर रहा हूं, लेकिन कृपया इसे अपने उत्तर को बाधित न होने दें। अगर रूबी-विशिष्ट लाइब्रेरी या कुछ है, हालांकि, यह जानना अच्छा है।)

https://code.i-harness.com


क्या होगा यदि आपके पास कोई समाप्ति तिथि नहीं है? अंतरिक्ष के रूप में सस्ते के रूप में, आपके पास अनंत स्थान नहीं है, इसलिए समाधान 2 एक गैर स्टार्टर है ...

क्या मैं सुझाव दे सकता हूं कि सदी के अंत में समाप्ति तिथि को "कोई समाप्ति तिथि" हल नहीं किया जा सकता है। यहां तक ​​कि एक दिन की घटना के लिए अंतरिक्ष की मात्रा सस्ता बनी हुई है।


  1. पुनरावृत्ति नियम का ट्रैक रखें (शायद iCalendar पर आधारित, प्रति @ क्रिस के। )। इसमें एक पैटर्न और एक श्रेणी शामिल होगी (प्रत्येक तीसरे मंगलवार, 10 घटनाओं के लिए)।
  2. जब आप किसी विशिष्ट घटना को संपादित / हटाना चाहते हैं, तो उपर्युक्त पुनरावृत्ति नियम के लिए अपवाद तिथियों का ट्रैक रखें (तिथियां जहां नियम निर्दिष्ट नियम के रूप में नहीं होता है)।
  3. यदि आपने हटा दिया है, तो आपको बस इतना ही चाहिए, अगर आपने संपादित किया है, तो एक और ईवेंट बनाएं, और इसे मुख्य ईवेंट में एक मूल आईडी सेट दें। आप यह चुन सकते हैं कि इस रिकॉर्ड में सभी मुख्य घटनाओं की जानकारी शामिल करना है, या यदि यह केवल परिवर्तन रखता है और जो कुछ भी नहीं बदलता है उसे प्राप्त करता है।

ध्यान दें कि यदि आप पुनरावृत्ति नियमों को समाप्त नहीं करते हैं जो समाप्त नहीं होते हैं, तो आपको अब अपनी असीमित जानकारी को प्रदर्शित करने के तरीके के बारे में सोचना होगा।

उम्मीद है की वो मदद करदे!


आप iCalendar सॉफ़्टवेयर कार्यान्वयन या मानक स्वयं ( आरएफसी 2445 आरएफसी 5545 ) देखना चाहते हैं। मोज़िला परियोजनाओं को जल्दी से ध्यान में आने के लिए लोग http://www.mozilla.org/projects/calendar/ एक त्वरित खोज http://icalendar.rubyforge.org/ को भी प्रकट करते हैं।

अन्य विकल्पों पर विचार किया जा सकता है कि आप घटनाओं को कैसे स्टोर करने जा रहे हैं। क्या आप अपना खुद का डेटाबेस स्कीमा बना रहे हैं? ICalendar- आधारित, आदि का उपयोग करना?


आप ईवेंट को iCalendar प्रारूप में सीधे स्टोर करते हैं, जो ओपन-एंडेड पुनरावृत्ति, समय-क्षेत्र स्थानीयकरण और आगे के लिए अनुमति देता है।

आप इन्हें एक CalDAV सर्वर में संग्रहीत कर सकते हैं और फिर जब आप ईवेंट प्रदर्शित करना चाहते हैं तो आप CalDAV में परिभाषित रिपोर्ट के विकल्प का उपयोग कर सकते हैं ताकि सर्वर को आवर्ती अवधि में पुनरावर्ती घटनाओं का विस्तार करने के लिए कहा जा सके।

या आप उन्हें डेटाबेस में स्वयं स्टोर कर सकते हैं और बैकएंड CalDAV सर्वर से बात करने के लिए पुट / जीईटी / रिपोर्ट की आवश्यकता के बिना, विस्तार करने के लिए किसी प्रकार की iCalendar पार्सिंग लाइब्रेरी का उपयोग कर सकते हैं। यह शायद अधिक काम है - मुझे यकीन है कि CalDAV सर्वर कहीं जटिलता छुपाते हैं।

ICalendar प्रारूप में ईवेंट होने से शायद लंबे समय तक चीजों को आसान बना दिया जाएगा क्योंकि लोग हमेशा उन्हें अन्य सॉफ़्टवेयर में डालने के लिए निर्यात करना चाहते हैं।


इन उत्तरों से, मैंने एक समाधान को हल किया है। मुझे वास्तव में लिंक अवधारणा का विचार पसंद है। पुनरावर्ती घटनाएं एक लिंक्ड सूची हो सकती हैं, पूंछ के साथ इसके पुनरावृत्ति नियम को जानना। एक ईवेंट बदलना आसान होगा, क्योंकि लिंक जगह पर रहते हैं, और एक ईवेंट को हटाना भी आसान है - आप बस किसी ईवेंट को अनलिंक करते हैं, इसे हटाते हैं, और इसके पहले और उसके बाद ईवेंट को फिर से लिंक करते हैं। आपको अभी भी आवर्ती घटनाओं से पूछताछ करना पड़ता है जब भी कोई व्यक्ति किसी नए समय की अवधि को कैलेंडर पर पहले कभी नहीं देखता, लेकिन अन्यथा यह बहुत साफ है।


घटनाओं को दोहराए जाने और गतिशील रूप से प्रदर्शित करने के रूप में स्टोर करें, हालांकि पुनरावर्ती घटना को विशिष्ट घटनाओं की एक सूची रखने की अनुमति दें जो किसी विशिष्ट दिन पर डिफ़ॉल्ट जानकारी को ओवरराइड कर सकें।

जब आप पुनरावर्ती घटना से पूछताछ करते हैं तो वह उस दिन के लिए एक विशिष्ट ओवरराइड की जांच कर सकता है।

यदि कोई उपयोगकर्ता परिवर्तन करता है, तो आप पूछ सकते हैं कि क्या वह सभी उदाहरणों (डिफ़ॉल्ट विवरण) या उस दिन के लिए अपडेट करना चाहता है (एक नया विशिष्ट ईवेंट बनाएं और इसे सूची में जोड़ें)।

यदि कोई उपयोगकर्ता इस घटना के सभी पुनरावर्तनों को हटाने के लिए कहता है तो आपके पास विनिर्देशों की सूची भी हाथ में है और उन्हें आसानी से हटा सकती है।

एकमात्र समस्याग्रस्त मामला होगा यदि उपयोगकर्ता इस घटना और सभी भविष्य की घटनाओं को अपडेट करना चाहता है। इस मामले में आपको पुनरावर्ती घटना को दो में विभाजित करना होगा। इस बिंदु पर आप पुनरावर्ती घटनाओं को किसी भी तरह से जोड़ने पर विचार करना चाहेंगे ताकि आप उन्हें हटा सकें।


तीन अच्छी रूबी तिथि / समय पुस्तकालयों के लिए नीचे दिए गए लेख को देखें। विशेष रूप से ice_cube पुनरावृत्ति नियमों और अन्य सामानों के लिए एक ठोस विकल्प लगता है जो एक ईवेंट कैलेंडर की आवश्यकता होगी। http://www.rubyinside.com/3-new-date-and-time-libraries-for-rubyists-3238.html


पुनरावर्ती घटनाओं के साथ कई समस्याएं हो सकती हैं, मुझे उन कुछ को हाइलाइट करने दें जिन्हें मैं जानता हूं।

समाधान 1 - कोई उदाहरण नहीं

मूल नियुक्ति + पुनरावृत्ति डेटा स्टोर करें, सभी उदाहरणों को स्टोर न करें।

समस्या का:

  • जब आपको उनकी ज़रूरत होती है, तो आपको डेट विंडो में सभी उदाहरणों की गणना करनी होगी
  • अपवादों को संभालने में असमर्थ (यानी आप किसी एक उदाहरण को हटाते हैं, या इसे स्थानांतरित करते हैं, या इसके बजाय, आप इस समाधान के साथ ऐसा नहीं कर सकते हैं)

समाधान 2 - स्टोर के उदाहरण

1 से सबकुछ स्टोर करें, लेकिन सभी इंस्टेंस, मूल नियुक्ति पर वापस लिंक करें।

समस्या का:

  • बहुत सारी जगह लेती है (लेकिन अंतरिक्ष सस्ता है, इतना मामूली)
  • अपवादों को सुन्दर तरीके से संभाला जाना चाहिए, खासकर यदि आप वापस जाएं और अपवाद बनाने के बाद मूल नियुक्ति संपादित करें। उदाहरण के लिए, यदि आप तीसरे उदाहरण को एक दिन आगे ले जाते हैं, तो क्या होगा यदि आप वापस जाएं और मूल नियुक्ति के समय को संपादित करें, तो मूल दिन पर एक और डालें और स्थानांतरित हो जाएं? स्थानांतरित एक को अनलिंक करें? स्थानांतरित एक उचित रूप से बदलने की कोशिश करें?

बेशक, यदि आप अपवाद नहीं करने जा रहे हैं, तो समाधान ठीक होना चाहिए, और आप मूल रूप से एक समय / अंतरिक्ष व्यापार से परिदृश्य से चुनते हैं।


मैं निम्नलिखित के साथ काम कर रहा हूँ:

और एक मणि प्रगति में है जो एक इनपुट प्रकार के साथ फॉर्मेटास्टिक बढ़ाता है: पुनरावर्ती ( form.schedule :as => :recurring ), जो form.schedule :as => :recurring जैसे इंटरफ़ेस और before_filter को दृश्य को क्रमशः एक IceCube ऑब्जेक्ट में क्रमबद्ध करने के लिए प्रस्तुत करता है, ghetto-ly।

मेरा विचार यह है कि इसे मॉडल में पुनरावर्ती विशेषताओं को जोड़ने के लिए अविश्वसनीयता बनाना आसान हो और इसे आसानी से कनेक्ट करें। सब कुछ लाइनों में।

तो यह मुझे क्या देता है? अनुक्रमित, संपादन योग्य, आवर्ती विशेषताएं।

events एक दिन का उदाहरण संग्रहीत करता है, और इसका उपयोग कैलेंडर दृश्य / सहायक में किया जाता है, task.schedule yaml'd IceCube ऑब्जेक्ट को संग्रहीत करता है, ताकि आप कॉल कर सकें: task.schedule.next_suggestion

संक्षेप में: मैं कैलेंडर प्रदर्शन के लिए दो मॉडल, एक फ्लैट, और कार्यक्षमता के लिए एक विशेषता का उपयोग करता हूं।


मैं पुनरावृत्ति पैरामीटर को संग्रहीत करने के लिए नीचे वर्णित डेटाबेस स्कीमा का उपयोग कर रहा हूं

http://github.com/bakineggs/recurring_events_for

फिर मैं गतिशील रूप से तिथियों की गणना करने के लिए रनट का उपयोग करता हूं।

Runt


मैंने कई कैलेंडर-आधारित अनुप्रयोग विकसित किए हैं, और पुन: प्रयोज्य जावास्क्रिप्ट कैलेंडर घटकों का एक सेट भी लिखा है जो पुनरावृत्ति का समर्थन करते हैं। मैंने पुनरावृत्ति के लिए डिजाइन करने के तरीके के बारे में एक सिंहावलोकन लिखा जो किसी के लिए सहायक हो सकता है। जबकि कुछ बिट्स हैं जो मैंने लिखी लाइब्रेरी के लिए विशिष्ट हैं, लेकिन सलाह दी गई अधिकांश बहुमत किसी भी कैलेंडर कार्यान्वयन के लिए सामान्य है।

कुछ प्रमुख बिंदु:

  • ICal RRULE प्रारूप का उपयोग करके पुनरावृत्ति स्टोर करें - यह एक ऐसा पहिया है जिसे आप वास्तव में पुन: पेश नहीं करना चाहते हैं
  • अपने डेटाबेस में पंक्तियों के रूप में व्यक्तिगत पुनरावर्ती घटना उदाहरणों को स्टोर न करें! हमेशा एक पुनरावृत्ति पैटर्न स्टोर करें।
  • आपके ईवेंट / अपवाद स्कीमा को डिज़ाइन करने के कई तरीके हैं, लेकिन मूल प्रारंभिक बिंदु उदाहरण प्रदान किया जाता है
  • सभी दिनांक / समय मान यूटीसी में संग्रहीत किए जाने चाहिए और प्रदर्शन के लिए स्थानीय रूपांतरित हो सकते हैं
  • पुनरावर्ती घटना के लिए संग्रहीत अंतिम तिथि हमेशा पुनरावृत्ति रेंज (या आपके प्लेटफॉर्म की "अधिकतम तिथि" की आवृत्ति "हमेशा के लिए" की अंतिम तिथि होनी चाहिए और घटना अवधि अलग से संग्रहित की जानी चाहिए। यह बाद में घटनाओं के लिए पूछताछ का एक सौहार्दपूर्ण तरीका सुनिश्चित करना है।
  • इवेंट इंस्टेंस और पुनरावृत्ति संपादन रणनीतियों को उत्पन्न करने के आसपास कुछ चर्चा शामिल है

यह वास्तव में एक जटिल विषय है जिसमें इसे लागू करने के लिए कई मान्य दृष्टिकोण हैं। मैं कहूंगा कि मैंने वास्तव में कई बार सफलतापूर्वक पुनरावृत्ति लागू की है, और मैं इस विषय पर सलाह लेने से सावधान रहूंगा जिसने वास्तव में ऐसा नहीं किया है।


मैंने बस इस सुविधा को लागू किया है! तर्क निम्नानुसार है, सबसे पहले आपको दो टेबल की आवश्यकता है। नियमटेबल स्टोर सामान्य या रीसायकल पैतृक घटनाओं। ItemTable चक्र घटनाओं को संग्रहीत किया जाता है। उदाहरण के लिए, जब आप एक चक्रीय घटना बनाते हैं, 6 नवंबर 2015 के लिए प्रारंभ समय, 6 दिसंबर (या हमेशा के लिए) के लिए अंतिम समय, एक सप्ताह के लिए चक्र। आप नियम को एक नियम में सम्मिलित करते हैं, फ़ील्ड निम्नानुसार हैं:

TableID: 1 Name: cycleA  
StartTime: 6 November 2014 (I kept thenumber of milliseconds),  
EndTime: 6 November 2015 (if it is repeated forever, and you can keep the value -1) 
Cycletype: WeekLy.

अब आप 20 नवंबर से 20 दिसंबर तक डेटा पूछना चाहते हैं। शुरुआती और समाप्ति समय, वीकली के आधार पर आप एक फ़ंक्शन रिकूरिंगएवेंटबीई (लंबी शुरुआत, लंबी अंत) लिख सकते हैं, आप अपने इच्छित संग्रह की गणना कर सकते हैं, <cycleA11.20, cycleA 11.27, cycleA 12.4 ......>। 6 नवंबर के अलावा, और बाकी मैंने उसे एक आभासी घटना कहा। जब उपयोगकर्ता वर्चुअल इवेंट 'नाम बदलता है (उदाहरण के लिए cycleA11.27), तो आप एक आइटमटेबल में डेटा डालते हैं। निम्नानुसार फ़ील्ड हैं:

TableID: 1 
Name, cycleB  
StartTime, 27 November 2014  
EndTime,November 6 2015  
Cycletype, WeekLy
Foreignkey, 1 (pointingto the table recycle paternal events).

फ़ंक्शन RecurringEventBE (लंबी शुरुआत, लंबा अंत) में, आप इस डेटा का उपयोग वर्चुअल इवेंट (cycleB11.27) को मेरे अंग्रेजी के बारे में खेद करते हैं, मैंने कोशिश की।

यह मेरा आवर्ती है INTBE:

public static List<Map<String, Object>> recurringData(Context context,
        long start, long end) { // 重复事件的模板处理,生成虚拟事件(根据日期段)
     long a = System.currentTimeMillis();
    List<Map<String, Object>> finalDataList = new ArrayList<Map<String, Object>>();

    List<Map<String, Object>> tDataList = BillsDao.selectTemplateBillRuleByBE(context); //RuleTable,just select recurringEvent
    for (Map<String, Object> iMap : tDataList) {

        int _id = (Integer) iMap.get("_id");
        long bk_billDuedate = (Long) iMap.get("ep_billDueDate"); // 相当于事件的开始日期 Start
        long bk_billEndDate = (Long) iMap.get("ep_billEndDate"); // 重复事件的截止日期 End
        int bk_billRepeatType = (Integer) iMap.get("ep_recurringType"); // recurring Type 

        long startDate = 0; // 进一步精确判断日记起止点,保证了该段时间断获取的数据不未空,减少不必要的处理
        long endDate = 0;

        if (bk_billEndDate == -1) { // 永远重复事件的处理

            if (end >= bk_billDuedate) {
                endDate = end;
                startDate = (bk_billDuedate <= start) ? start : bk_billDuedate; // 进一步判断日记起止点,这样就保证了该段时间断获取的数据不未空
            }

        } else {

            if (start <= bk_billEndDate && end >= bk_billDuedate) { // 首先判断起止时间是否落在重复区间,表示该段时间有重复事件
                endDate = (bk_billEndDate >= end) ? end : bk_billEndDate;
                startDate = (bk_billDuedate <= start) ? start : bk_billDuedate; // 进一步判断日记起止点,这样就保证了该段时间断获取的数据不未空
            }
        }

        Calendar calendar = Calendar.getInstance();
        calendar.setTimeInMillis(bk_billDuedate); // 设置重复的开始日期

        long virtualLong = bk_billDuedate; // 虚拟时间,后面根据规则累加计算
        List<Map<String, Object>> virtualDataList = new ArrayList<Map<String, Object>>();// 虚拟事件

        if (virtualLong == startDate) { // 所要求的时间,小于等于父本时间,说明这个是父事件数据,即第一条父本数据

            Map<String, Object> bMap = new HashMap<String, Object>();
            bMap.putAll(iMap);
            bMap.put("indexflag", 1); // 1表示父本事件
            virtualDataList.add(bMap);
        }

        long before_times = 0; // 计算从要求时间start到重复开始时间的次数,用于定位第一次发生在请求时间段落的时间点
        long remainder = -1;
        if (bk_billRepeatType == 1) {

            before_times = (startDate - bk_billDuedate) / (7 * DAYMILLIS);
            remainder = (startDate - bk_billDuedate) % (7 * DAYMILLIS);

        } else if (bk_billRepeatType == 2) {

            before_times = (startDate - bk_billDuedate) / (14 * DAYMILLIS);
            remainder = (startDate - bk_billDuedate) % (14 * DAYMILLIS);

        } else if (bk_billRepeatType == 3) {

            before_times = (startDate - bk_billDuedate) / (28 * DAYMILLIS);
            remainder = (startDate - bk_billDuedate) % (28 * DAYMILLIS);

        } else if (bk_billRepeatType == 4) {

            before_times = (startDate - bk_billDuedate) / (15 * DAYMILLIS);
            remainder = (startDate - bk_billDuedate) % (15 * DAYMILLIS);

        } else if (bk_billRepeatType == 5) {

            do { // 该段代码根据日历处理每天重复事件,当事件比较多的时候效率比较低

                Calendar calendarCloneCalendar = (Calendar) calendar
                        .clone();
                int currentMonthDay = calendarCloneCalendar
                        .get(Calendar.DAY_OF_MONTH);
                calendarCloneCalendar.add(Calendar.MONTH, 1);
                int nextMonthDay = calendarCloneCalendar
                        .get(Calendar.DAY_OF_MONTH);

                if (currentMonthDay > nextMonthDay) {
                    calendar.add(Calendar.MONTH, 1 + 1);
                    virtualLong = calendar.getTimeInMillis();
                } else {
                    calendar.add(Calendar.MONTH, 1);
                    virtualLong = calendar.getTimeInMillis();
                }

            } while (virtualLong < startDate);

        } else if (bk_billRepeatType == 6) {

            do { // 该段代码根据日历处理每天重复事件,当事件比较多的时候效率比较低

                Calendar calendarCloneCalendar = (Calendar) calendar
                        .clone();
                int currentMonthDay = calendarCloneCalendar
                        .get(Calendar.DAY_OF_MONTH);
                calendarCloneCalendar.add(Calendar.MONTH, 2);
                int nextMonthDay = calendarCloneCalendar
                        .get(Calendar.DAY_OF_MONTH);

                if (currentMonthDay > nextMonthDay) {
                    calendar.add(Calendar.MONTH, 2 + 2);
                    virtualLong = calendar.getTimeInMillis();
                } else {
                    calendar.add(Calendar.MONTH, 2);
                    virtualLong = calendar.getTimeInMillis();
                }

            } while (virtualLong < startDate);

        } else if (bk_billRepeatType == 7) {

            do { // 该段代码根据日历处理每天重复事件,当事件比较多的时候效率比较低

                Calendar calendarCloneCalendar = (Calendar) calendar
                        .clone();
                int currentMonthDay = calendarCloneCalendar
                        .get(Calendar.DAY_OF_MONTH);
                calendarCloneCalendar.add(Calendar.MONTH, 3);
                int nextMonthDay = calendarCloneCalendar
                        .get(Calendar.DAY_OF_MONTH);

                if (currentMonthDay > nextMonthDay) {
                    calendar.add(Calendar.MONTH, 3 + 3);
                    virtualLong = calendar.getTimeInMillis();
                } else {
                    calendar.add(Calendar.MONTH, 3);
                    virtualLong = calendar.getTimeInMillis();
                }

            } while (virtualLong < startDate);

        } else if (bk_billRepeatType == 8) {

            do {
                calendar.add(Calendar.YEAR, 1);
                virtualLong = calendar.getTimeInMillis();
            } while (virtualLong < startDate);

        }

        if (remainder == 0 && virtualLong != startDate) { // 当整除的时候,说明当月的第一天也是虚拟事件,判断排除为父本,然后添加。不处理,一个月第一天事件会丢失
            before_times = before_times - 1;
        }

        if (bk_billRepeatType == 1) { // 单独处理天事件,计算出第一次出现在时间段的事件时间

            virtualLong = bk_billDuedate + (before_times + 1) * 7
                    * (DAYMILLIS);
            calendar.setTimeInMillis(virtualLong);

        } else if (bk_billRepeatType == 2) {

            virtualLong = bk_billDuedate + (before_times + 1) * (2 * 7)
                    * DAYMILLIS;
            calendar.setTimeInMillis(virtualLong);
        } else if (bk_billRepeatType == 3) {

            virtualLong = bk_billDuedate + (before_times + 1) * (4 * 7)
                    * DAYMILLIS;
            calendar.setTimeInMillis(virtualLong);
        } else if (bk_billRepeatType == 4) {

            virtualLong = bk_billDuedate + (before_times + 1) * (15)
                    * DAYMILLIS;
            calendar.setTimeInMillis(virtualLong);
        }

        while (startDate <= virtualLong && virtualLong <= endDate) { // 插入虚拟事件
            Map<String, Object> bMap = new HashMap<String, Object>();
            bMap.putAll(iMap);
            bMap.put("ep_billDueDate", virtualLong);
            bMap.put("indexflag", 2); // 2表示虚拟事件
            virtualDataList.add(bMap);

            if (bk_billRepeatType == 1) {

                calendar.add(Calendar.DAY_OF_MONTH, 7);

            } else if (bk_billRepeatType == 2) {

                calendar.add(Calendar.DAY_OF_MONTH, 2 * 7);

            } else if (bk_billRepeatType == 3) {

                calendar.add(Calendar.DAY_OF_MONTH, 4 * 7);

            } else if (bk_billRepeatType == 4) {

                calendar.add(Calendar.DAY_OF_MONTH, 15);

            } else if (bk_billRepeatType == 5) {

                Calendar calendarCloneCalendar = (Calendar) calendar
                        .clone();
                int currentMonthDay = calendarCloneCalendar
                        .get(Calendar.DAY_OF_MONTH);
                calendarCloneCalendar.add(Calendar.MONTH,
                        1);
                int nextMonthDay = calendarCloneCalendar
                        .get(Calendar.DAY_OF_MONTH);

                if (currentMonthDay > nextMonthDay) {
                    calendar.add(Calendar.MONTH, 1
                            + 1);
                } else {
                    calendar.add(Calendar.MONTH, 1);
                }

            }else if (bk_billRepeatType == 6) {

                Calendar calendarCloneCalendar = (Calendar) calendar
                        .clone();
                int currentMonthDay = calendarCloneCalendar
                        .get(Calendar.DAY_OF_MONTH);
                calendarCloneCalendar.add(Calendar.MONTH,
                        2);
                int nextMonthDay = calendarCloneCalendar
                        .get(Calendar.DAY_OF_MONTH);

                if (currentMonthDay > nextMonthDay) {
                    calendar.add(Calendar.MONTH, 2
                            + 2);
                } else {
                    calendar.add(Calendar.MONTH, 2);
                }

            }else if (bk_billRepeatType == 7) {

                Calendar calendarCloneCalendar = (Calendar) calendar
                        .clone();
                int currentMonthDay = calendarCloneCalendar
                        .get(Calendar.DAY_OF_MONTH);
                calendarCloneCalendar.add(Calendar.MONTH,
                        3);
                int nextMonthDay = calendarCloneCalendar
                        .get(Calendar.DAY_OF_MONTH);

                if (currentMonthDay > nextMonthDay) {
                    calendar.add(Calendar.MONTH, 3
                            + 3);
                } else {
                    calendar.add(Calendar.MONTH, 3);
                }

            } else if (bk_billRepeatType == 8) {

                calendar.add(Calendar.YEAR, 1);

            }
            virtualLong = calendar.getTimeInMillis();

        }

        finalDataList.addAll(virtualDataList);

    }// 遍历模板结束,产生结果为一个父本加若干虚事件的list

    /*
     * 开始处理重复特例事件特例事件,并且来时合并
     */
    List<Map<String, Object>>oDataList = BillsDao.selectBillItemByBE(context, start, end);
    Log.v("mtest", "特例结果大小" +oDataList );


    List<Map<String, Object>> delectDataListf = new ArrayList<Map<String, Object>>(); // finalDataList要删除的结果
    List<Map<String, Object>> delectDataListO = new ArrayList<Map<String, Object>>(); // oDataList要删除的结果


    for (Map<String, Object> fMap : finalDataList) { // 遍历虚拟事件

        int pbill_id = (Integer) fMap.get("_id");
        long pdue_date = (Long) fMap.get("ep_billDueDate");

        for (Map<String, Object> oMap : oDataList) {

            int cbill_id = (Integer) oMap.get("billItemHasBillRule");
            long cdue_date = (Long) oMap.get("ep_billDueDate");
            int bk_billsDelete = (Integer) oMap.get("ep_billisDelete");

            if (cbill_id == pbill_id) {

                if (bk_billsDelete == 2) {// 改变了duedate的特殊事件
                    long old_due = (Long) oMap.get("ep_billItemDueDateNew");

                    if (old_due == pdue_date) {

                        delectDataListf.add(fMap);//该改变事件在时间范围内,保留oMap

                    }

                } else if (bk_billsDelete == 1) {

                    if (cdue_date == pdue_date) {

                        delectDataListf.add(fMap);
                        delectDataListO.add(oMap);

                    }

                } else {

                    if (cdue_date == pdue_date) {
                        delectDataListf.add(fMap);
                    }

                }

            }
        }// 遍历特例事件结束

    }// 遍历虚拟事件结束
    // Log.v("mtest", "delectDataListf的大小"+delectDataListf.size());
    // Log.v("mtest", "delectDataListO的大小"+delectDataListO.size());
    finalDataList.removeAll(delectDataListf);
    oDataList.removeAll(delectDataListO);
    finalDataList.addAll(oDataList);
    List<Map<String, Object>> mOrdinaryList = BillsDao.selectOrdinaryBillRuleByBE(context, start, end);
    finalDataList.addAll(mOrdinaryList);
    // Log.v("mtest", "finalDataList的大小"+finalDataList.size());
    long b = System.currentTimeMillis();
    Log.v("mtest", "算法耗时"+(b-a));

    return finalDataList;
}   






recurrence