Example #1
0
    def test_localize(self):
        settings.defaults({'timezone': {'local': 'US/Eastern'}})

        now = datetime.datetime.now()
        localized = time_util.localize(now)

        assert localized.tzinfo
        assert str(localized.tzinfo) == str(time_util.local_tz())
    def test_localize(self):
        settings.defaults({'timezone': {
            'local': 'US/Eastern'
        }})

        now = datetime.datetime.now()
        localized = time_util.localize(now)

        assert localized.tzinfo
        assert str(localized.tzinfo) == str(time_util.local_tz())
    A filter to automatically encode a variable as json
    e.g. {{user|json}} renders {'email': '*****@*****.**'}
    """
    return json.dumps(obj, *args, cls=DatastoreEncoder, **kwargs)


def _is_datetime(obj):
    return isinstance(obj, datetime.datetime)


#
# Formatters
#

formatters = {
    datetime.datetime: lambda x: time_util.localize(x).strftime('%b %d, %Y at %I:%M%p %Z'),
    datetime.date: lambda x: x.strftime('%b %d, %Y'),
    ndb.Key: lambda x: format_value(x.get())
}


def format_value(val):
    if isinstance(val, types.StringTypes):
        return val

    if isinstance(val, collections.Iterable):
        return u', '.join([format_value(x) for x in val])

    formatter = formatters.get(type(val))

    if formatter:
Example #4
0
    def api_generate_report(self, tz_offset=None):
        tz_offset = float(tz_offset) if tz_offset else 0

        fields = [
            'Timestamp', 'The action performed', 'How the action was invoked',
            'What App User invoked the action', 'Targetted user or resource',
            'Target event altered', 'Comment'
        ]

        now = datetime.now()
        local_now = time_util.localize(now,
                                       tz=dateutil.tz.tzoffset(
                                           None, tz_offset * 60 * 60))
        tomorrow = local_now + timedelta(days=1)
        weeks = now - timedelta(weeks=2)
        fromdate = time_util.localize(datetime(weeks.year, weeks.month,
                                               weeks.day, 0, 0, 0),
                                      tz=dateutil.tz.tzoffset(None, 0))
        todate = time_util.localize(datetime(tomorrow.year, tomorrow.month,
                                             tomorrow.day, 0, 0, 0),
                                    tz=dateutil.tz.tzoffset(None, 0))

        logging.info("RANGE: %s %s " % (fromdate, todate))
        out = StringIO.StringIO()
        logs = AuditLogModel.fetch_date_range(fromdate, todate)
        # writer = UnicodeDictWriter(out, fields)
        writer = csv.DictWriter(out, fieldnames=fields)

        writer.writeheader()

        for log in logs.iter():
            if type(log.action) is not 'NoneType':
                log.action.encode('utf-8').strip()

            if type(log.how_the_action_invoked) is unicode:
                log.how_the_action_invoked.encode('utf-8').strip()

            if type(log.app_user_invoked_action) is unicode:
                log.app_user_invoked_action.encode('utf-8').strip()

            if type(log.target_resource) is unicode:
                log.target_resource.encode('utf-8').strip()

            if type(log.target_event_altered) is unicode:
                log.target_event_altered.encode('utf-8').strip()

            if type(log.comment) is not 'NoneType':
                log.comment.encode('utf-8').strip()
                logging.info('COMMENT: %s' % log.comment)

            data = {
                "Timestamp": datetime.strftime(log.created,
                                               '%m/%d/%Y %I:%M:%S %p'),
                "The action performed": log.action,
                "How the action was invoked": log.how_the_action_invoked,
                "What App User invoked the action":
                log.app_user_invoked_action,
                "Targetted user or resource": log.target_resource,
                "Target event altered": log.target_event_altered,
                "Comment": log.comment
            }

            writer.writerow(data)

        self.response.headers[
            'Content-Type'] = 'application/ms-excel;charset=UTF-8'
        self.response.headers['Content-Transfer-Encoding'] = 'Binary'
        self.response.headers[
            'Content-disposition'] = 'attachment; filename="arista-calendar-log-%s.csv"' % datetime.now(
            ).strftime("%Y-%m-%d_%H:%M:%S")
        self.response.out.write(out.getvalue())
        out.close()
        return self.response