def test_get_occurrences(self):
        result = get_occurrences(self.portal,
                                 get_portal_events(self.portal))
        self.assertTrue(len(result) == 9)

        result = get_occurrences(self.portal,
                                 get_portal_events(self.portal), limit=5)
        self.assertTrue(len(result) == 5)
        self.assertTrue(IEventAccessor.providedBy(result[0]))
    def test_get_portal_events(self):

        # whole range
        res = get_portal_events(self.portal)
        self.assertTrue(len(res) == 4)

        res = get_portal_events(self.portal, range_start=self.past, range_end=self.future)
        self.assertTrue(len(res) == 4)

        res = get_portal_events(self.portal, range_end=self.future)
        self.assertTrue(len(res) == 4)

        res = get_portal_events(self.portal, range_start=self.past)
        self.assertTrue(len(res) == 4)

        # only on now-date
        res = get_portal_events(self.portal, range_start=self.now, range_end=self.now)
        self.assertTrue(len(res) == 2)

        # only on past date
        res = get_portal_events(self.portal, range_start=self.past, range_end=self.past)
        self.assertTrue(len(res) == 2)

        # one recurrence occurrence in future
        res = get_portal_events(self.portal, range_start=self.far, range_end=self.far)
        self.assertTrue(len(res) == 1)

        # from now on
        res = get_portal_events(self.portal, range_start=self.now)
        self.assertTrue(len(res) == 3)

        # until now
        res = get_portal_events(self.portal, range_end=self.now)
        self.assertTrue(len(res) == 3)
Example #3
0
def calendar_from_collection(context):
    """Container/Event adapter. Returns an icalendar.Calendar object from a
    Collection.

    """
    context = aq_inner(context)
    result = get_portal_events(context)
    return construct_calendar(context, result)
Example #4
0
def calendar_from_container(context):
    """Container adapter. Returns an icalendar.Calendar object from a
    Containerish context like a Folder.

    """
    context = aq_inner(context)
    path = '/'.join(context.getPhysicalPath())
    result = get_portal_events(context, path=path)
    return construct_calendar(context, result)
    def test_get_occurrences(self):
        brains = get_portal_events(self.portal)

        result = get_occurrences_from_brains(self.portal, brains)
        self.assertTrue(len(result) == 9)

        result = get_occurrences_from_brains(self.portal, brains,
                range_start=self.now)
        self.assertTrue(len(result) == 9)

        result = get_occurrences_from_brains(self.portal, brains, limit=5)
        self.assertTrue(len(result) == 5)
        self.assertTrue(IEventAccessor.providedBy(result[0]))
Example #6
0
def calendar_from_container(context):
    """ Container adapter. Returns an icalendar.Calendar object from a
    Containerish context like a Folder.

    """
    context = aq_inner(context)
    path = '/'.join(context.getPhysicalPath())
    result = get_portal_events(context, path=path)
    events = [item.getObject() for item in result]
    # TODO: should i become a generator?
    # TODO: let construct_calendar expand brains to objects - so a
    # generator would make some sense...
    return construct_calendar(context, events)
Example #7
0
 def get_data(self):
     start = guess_date_from(self.request.form.get('start', ''))
     limit = self.request.form.get('limit', None)
     b_size = self.request.form.get('b_size', 20)
     b_start = self.request.form.get('b_start', 0)
     result = get_portal_events(self.context, range_start=start)
     # TODO: performance issue! the batch is somehow useless, if we
     # calculate every result item anyways.
     occ = [IEventAccessor(occ) for occ in\
            get_occurrences(self.context,
                            result,
                            range_start=start,
                            limit=limit)]
     return Batch(occ, b_size, b_start)
    def _data(self):
        context = aq_inner(self.context)
        data = self.data

        query_kw = {}
        if data.search_base:
            query_kw['path'] = {'query': '%s%s' % (
                '/'.join(self.portal.getPhysicalPath()), data.search_base)}

        if data.state:
            query_kw['review_state'] = data.state

        ret = get_portal_events(
                context,
                range_start=localized_now(context),
                limit=data.count,
                **query_kw)

        return ret
    def test_recurrence_indexing(self):
        utc = pytz.utc
        self.portal.invokeFactory('plone.app.event.dx.event', 'event1',
                start=datetime(2011,11,11,11,0, tzinfo=utc),
                end=datetime(2011,11,11,12,0, tzinfo=utc),
                timezone='UTC',
                whole_day=False)
        e1 = self.portal['event1']
        e1rec = IEventRecurrence(e1)
        e1rec.recurrence = 'RRULE:FREQ=DAILY;COUNT=4'
        e1.reindexObject()

        # test, if the recurrence attribute is available on the context.
        # DRI needs that for indexing.
        self.assertTrue(e1.recurrence == e1rec.recurrence)

        # test, if the occurrences are indexed by DRI
        result = get_portal_events(
                e1,
                range_start=datetime(2011,11,12,11,0, tzinfo=utc))
        self.assertTrue(len(result)==1)
Example #10
0
    def get_events(self, start=None, end=None, batch=True, mode=None):
        context = self.context

        mode = mode or self.mode
        if not mode and not start and not end:
            mode = "future"
        if mode:
            dt = None
            if self.date:
                try:
                    dt = guess_date_from(self.date)
                except TypeError:
                    pass
            start, end = start_end_from_mode(mode, dt, context)

        b_start = b_size = None
        if batch:
            b_start = self.b_start
            b_size = self.b_size

        occs = get_occurrences_from_brains(
            context,
            get_portal_events(
                context,
                start,
                end,
                # b_start=b_start, b_size=b_size,
                path=context.getPhysicalPath(),
            ),
            start,
            end,
        )

        if batch:
            ret = Batch(occs, size=b_size, start=b_start, orphan=self.orphan)
        else:
            ret = occs

        return ret