Python DateTime.earliestTime方法代码示例

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import earliestTime [as 别名]
    def getCriteriaItems(self):
        """Return a sequence of items to be used to build the catalog query.
        """
        if self.value is not None:
            field = self.Field()
            value = self.Value()

            # Negate the value for 'old' days
            if self.getDateRange() == '-':
                value = -value

            date = DateTime() + value
            current_date = DateTime()

            operation = self.getOperation()
            if operation == 'within_day':
                date_range = ( date.earliestTime(), date.latestTime() )
                return ( ( field, {'query': date_range, 'range': 'min:max'} ), )
            elif operation == 'more':
                if value != 0:
                    range_op = (self.getDateRange() == '-' and 'max') or 'min'
                    return ( ( field, {'query': date.earliestTime(), 'range': range_op} ), )
                else:
                    return ( ( field, {'query': date, 'range': 'min'} ), )
            elif operation == 'less':
                if value != 0:
                    date_range = (self.getDateRange() == '-' and
                                  (date.earliestTime(), current_date)
                                  ) or (current_date, date.latestTime())
                    return ( ( field, {'query': date_range, 'range': 'min:max'} ), )
                else:
                    return ( ( field, {'query': date, 'range': 'max'} ), )
        else:
            return ()

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import earliestTime [as 别名]
    def get_query(self):
        query = {
            'object_provides': 'ftw.news.interfaces.INews',
            'sort_on': 'start',
            'sort_order': 'reverse',
            'path': '/'.join(self.context.getPhysicalPath())
        }

        datestring = self.request.get('archive')
        if datestring:
            try:
                start = DateTime(datestring)
            except DateTime.interfaces.SyntaxError:
                raise
            end = DateTime('{0}/{1}/{2}'.format(
                start.year() + start.month() / 12,
                start.month() % 12 + 1,
                1)
            ) - 1
            query['start'] = {
                'query': (start.earliestTime(), end.latestTime()),
                'range': 'minmax',
            }

        return query

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import earliestTime [as 别名]
    def myhours(self):
        """Gets the content."""
        etool = getToolByName(self, TIMETOOLNAME)
        portal = self.portal
        user = getSecurityManager().getUser().getUserName()
        now = DateTime()
        start = now.earliestTime() - 6
        end = now.latestTime()
        hours = list(etool.getHours(node=portal, start=start, end=end,
                                    REQUEST=None, Creator=user))

        def earliestStart(hour):
            start = hour.start.earliestTime()
            # Ensure a clean date in the server timezone
            return DateTime(start.Date())

        hours.sort(key=earliestStart)
        by_date = dict((k, tuple(v))
                       for (k, v) in groupby(hours, earliestStart))
        results = []
        for i in range(7):
            date = start + i
            hours = by_date.get(date, ())
            results.append(dict(date=date,
                                sum=etool.countHours(hours)))
        return results

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import earliestTime [as 别名]
    def __init__(self, context, request):
        super(TimeReports, self).__init__(context, request)

        self.ettool = getToolByName(self.context, 'extropy_timetracker_tool')

        start = self.request.get('startdate', None)
        if not start:
            now = DateTime()
            # Default to showing the current year. During January we still
            # include the last year, as we usually still write bills for that
            # period.
            if now.month() > 1:
                start = '%s-01-01' % now.year()
            else:
                start = '%s-01-01' % (now.year() - 1)

        start = DateTime(start)
        self.start = start.earliestTime()

        end = self.request.get('enddate', None)
        end = end and DateTime(end) or DateTime()
        self.end = end.latestTime()

        self.query_string = make_query(*(
            {key: self.request[key]}
            for key in ('Creator', 'getBudgetCategory', 'startdate', 'enddate')
            if key in self.request))
        self.query_string = self.query_string and '?' + self.query_string

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import earliestTime [as 别名]
    def issueInvoice(self, REQUEST=None, RESPONSE=None):
        """ issue invoice
        """
        # check for an adhoc invoice batch for this month
        now = DateTime()
        batch_month = now.strftime("%b %Y")
        batch_title = "%s - %s" % (batch_month, "ad hoc")
        invoice_batch = None
        for b_proxy in self.portal_catalog(portal_type="InvoiceBatch", Title=batch_title):
            invoice_batch = b_proxy.getObject()
        if not invoice_batch:
            first_day = DateTime(now.year(), now.month(), 1)
            start_of_month = first_day.earliestTime()
            last_day = first_day + 31
            while last_day.month() != now.month():
                last_day = last_day - 1
            end_of_month = last_day.latestTime()

            invoices = self.invoices
            batch_id = invoices.generateUniqueId("InvoiceBatch")
            invoices.invokeFactory(id=batch_id, type_name="InvoiceBatch")
            invoice_batch = invoices._getOb(batch_id)
            invoice_batch.edit(title=batch_title, BatchStartDate=start_of_month, BatchEndDate=end_of_month)
            invoice_batch.processForm()

        client_uid = self.getClientUID()
        invoice_batch.createInvoice(client_uid, [self])

        RESPONSE.redirect("%s/analysisrequest_invoice" % self.absolute_url())

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import earliestTime [as 别名]
 def testsToday(self):
     today = DateTime()
     self.reportTitle = 'Tests Today: %s' % today.strftime(self.dateFormat)
     brains = self.portal_catalog.searchResults(sort_on='testDate', portal_type='BlueSheet',
                                                review_state=self.statesFromOfficeApprovalToAdministerTest)
     filteredBrains = filter((lambda b: b['testDate'] >= today.earliestTime() and b['testDate'] <= today.latestTime()), brains)
     self.results = self._convertBrainsToResultsDict(filteredBrains)
     return self.resultTemplate()

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import earliestTime [as 别名]
def _today(context, row):
    now = DateTime()
    start_date = now.earliestTime()
    end_date = now.latestTime()
    row = Row(index=row.index,
              operator=row.operator,
              values=(start_date, end_date))
    return _between(context, row)

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import earliestTime [as 别名]
 def test__today(self):
     now = DateTime()
     expected_dates = [now.earliestTime(), now.latestTime()]
     expected = {'modified': {'query': expected_dates, 'range': 'minmax'}}
     data = Row(index='modified',
               operator='_today',
               values=expected_dates)
     parsed = queryparser._today(MockSite(), data)
     self.assertEqual(parsed, expected)

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import earliestTime [as 别名]
 def test__lessThanRelativeDate(self):
     days = 2
     now = DateTime()
     mydate = now + days
     expected_dates = [now.earliestTime(), mydate.latestTime()]
     expected = {'modified': {'query': expected_dates, 'range': 'minmax'}}
     data = Row(index='modified',
               operator='_lessThanRelativeDate',
               values=days)
     parsed = queryparser._lessThanRelativeDate(MockSite(), data)
     self.assertEqual(parsed, expected)

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import earliestTime [as 别名]
def extend_query_by_date(query, datestring, date_field):
    try:
        start = DateTime(datestring)
    except dtSytaxError:
        return query
    end = DateTime('%s/%s/%s' % (start.year() + start.month() / 12,
                                 start.month() % 12 + 1, 1))
    end = end - 1
    query[date_field] = {'query': (start.earliestTime(),
                                    end.latestTime()),
                          'range': 'minmax'}
    return query

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import earliestTime [as 别名]
 def test__afterRelativeDate(self):
     days = 2
     now = DateTime()
     mydate = now.earliestTime() + days
     expected = {'effective': {'query': mydate, 'range': 'min'}}
     data = Row(
         index='effective',
         operator='_afterRelativeDate',
         values=days
     )
     parsed = queryparser._afterRelativeDate(MockSite(), data)
     self.assertEqual(parsed, expected)

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import earliestTime [as 别名]
 def test__beforeRelativeDate(self):
     days = 365
     now = DateTime()
     mydate = now.earliestTime() - days
     expected = {'modified': {'query': mydate, 'range': 'max'}}
     data = Row(
         index='modified',
         operator='_beforeRelativeDate',
         values=days
     )
     parsed = queryparser._beforeRelativeDate(MockSite(), data)
     self.assertEqual(parsed, expected)

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import earliestTime [as 别名]
    def test_DateTimeConversions( self ):
        now         = DateTime()
        now_db      = DB( now )
        today       = now.earliestTime()
        tomorrow    = today + 1
        yesterday   = today - 1

        assert( now <  self.Highball )
        assert( now >  self.Lowball )
        assert( now_db == now )
        assert( now == now_db )
        assert( yesterday < now_db < tomorrow )

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import earliestTime [as 别名]
def _lessThanRelativeDate(context, row):
    """ "Between now and N days from now." """
    # INFO: Values is the number of days
    try:
        values = int(row.values)
    except ValueError:
        values = 0
    now = DateTime()
    start_date = now.earliestTime()
    end_date = now + values
    end_date = end_date.latestTime()
    row = Row(index=row.index, operator=row.operator, values=(start_date, end_date))
    return _between(context, row)

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import earliestTime [as 别名]
 def getBlogItemsByDate(self, date, sort=1, pub_date_filter=1):
     """ return only those with pub_date within today """
     start_y, start_m, start_d = date.year(), date.month(), date.day()
     d = DateTime(start_y,start_m,start_d)
     r = (d.earliestTime(), d.latestTime())
     search = {'meta_type':BLOGITEM_METATYPE,
               'pub_date': {'query':r, 'range':'min:max'},
               'sort_on':'pub_date',
               'sort_order':'reverse',
               }
     blogitems = []
     for brain in self.getCatalog().searchResults(search):
         blogitems.append(brain.getObject())
     return blogitems