1

"""

     2

    Some additional helpers

     3

"""

     4

     5

import datetime

     6

import calendar as _calendar

     7

     8

import qmsk.web.helpers

     9

    10

import preferences, urls, config

    11

    12

class Helpers (qmsk.web.helpers.Helpers) :

    13

    """

    14

        Our set of helpers, inheriting from base helpers

    15

    """

    16

    17

    # set contructor...

    18

    set = set

    19

    20

    # reference to calendar instance

    21

    calendar = _calendar.Calendar()

    22

    23

    # list of (month_num, month_name) for the months in the year

    24

    months = list(enumerate(_calendar.month_name))[1:]

    25

    26

    def tz_name (self, tz) :

    27

        """

    28

            Returns a string describing the given timezone

    29

        """

    30

    31

        return self.now().strftime(config.TIMEZONE_FMT)

    32

    33

    def fmt_month (self, date) :

    34

        """

    35

            Formats a month

    36

        """

    37

    38

        return date.strftime(config.MONTH_FMT)

    39

    40

    def fmt_weekday (self, wday) :

    41

        """

    42

            Formats an abbreviated weekday name

    43

        """

    44

    45

        return _calendar.day_abbr[wday]

    46

    47

    def build_date (self, month, mday) :

    48

        """

    49

            Returns a datetime.datetime for the given (month.year, month.month, mday)

    50

        """

    51

    52

        return self.ctx['prefs'][preferences.timezone].localize(datetime.datetime(month.year, month.month, mday))

    53

    54

    def now (self) :

    55

        """

    56

            Build current time

    57

        """

    58

    59

        return self.ctx['prefs'][preferences.timezone].localize(datetime.datetime.now())

    60

    61

    def today (self) :

    62

        """

    63

            Build today's date

    64

        """

    65

    66

        return self.now().date()

    67

    68

    def is_today (self, dt) :

    69

        """

    70

            Checks if the given datetime.datetime is today

    71

        """

    72

    73

        # compare with current date

    74

        return dt.date() == self.today()

    75

    76

    def is_this_month (self, month) :

    77

        """

    78

            Checks the given month is the current month

    79

        """

    80

    81

        today = self.today()

    82

    83

        return (month.year == today.year and month.month == today.month)

    84

    85

    @staticmethod

    86

    def _wrap_year (year, month) :

    87

        """

    88

            Wraps month to between [1, 12], spilling overflow/underflow by to year.

    89

    90

            Returns (year, month)

    91

        """

    92

    93

        # underflow?

    94

        if month == 0 :

    95

            # wrap to previous year

    96

            return (year - 1, 12)

    97

    98

        # overflow?

    99

        elif month == 13 :

   100

            # wrap to next year

   101

            return (year + 1, 1)

   102

   103

        # sane value

   104

        elif 1 <= month <= 12 :

   105

            return (year, month)

   106

   107

        # insane value

   108

        else :

   109

            assert False, "invalid year/month: %d/%d" % (year, month)

   110

   111

    def prev_month (self, month) :

   112

        """

   113

            Returns the month preceding the given one (as a datetime.datetime)

   114

        """

   115

   116

        # previous month

   117

        y, m = self._wrap_year(month.year, month.month - 1)

   118

   119

        # build datetime

   120

        return datetime.datetime(year=y, month=m, day=1, tzinfo=month.tzinfo)

   121

   122

    def next_month (self, month) :

   123

        """

   124

            Returns the month following the given one (as a datetime.datetime)

   125

        """

   126

   127

        # previous month

   128

        y, m = self._wrap_year(month.year, month.month + 1)

   129

   130

        # build datetime

   131

        return datetime.datetime(year=y, month=m, day=1, tzinfo=month.tzinfo)

   132

   133

    def fmt_time (self, time=None) :

   134

        """

   135

            Format given time, or current time

   136

        """

   137

   138

        # defaults

   139

        if not time :

   140

            time = self.now()

   141

   142

        return time.strftime(self.ctx['prefs'][preferences.time_format])

   143

   144

    def fmt_date (self, date=None) :

   145

        """

   146

            Format given date, or current date

   147

        """

   148

   149

        # defaults

   150

        if not date :

   151

            date = self.now()

   152

   153

        return date.strftime(self.ctx['prefs'][preferences.date_format])

   154

   155

    def url (self, url, **params) :

   156

        """

   157

            Build URL with our request object

   158

        """

   159

   160

        return url.build(self.ctx['req'], **params)

   161

   162

    # old name

   163

    build_url = url

   164

   165

    def utc_timestamp (self, dtz) :

   166

        """

   167

            Build an UTC timestamp from the given datetime

   168

        """

   169

   170

        return urls.types['ts'].build(dtz)

   171

   172

    def skip_next (self, count, skip) :

   173

        """

   174

            Return skip offset for next page

   175

        """

   176

   177

        return count + skip

   178

   179

    def skip_page (self, count, page) :

   180

        """

   181

            Skip to page

   182

        """

   183

   184

        if page :

   185

            return count * page

   186

   187

        else :

   188

            return None

   189

   190

    def skip_prev (self, count, skip) :

   191

        """

   192

            Return skip offset for previous page, None for first page

   193

        """

   194

   195

        if skip > count :

   196

            return skip - count

   197

   198

        else :

   199

            return None

   200

   201

    def max (self, *values) :

   202

        """

   203

            Returns the largest of the given values

   204

        """

   205

   206

        return max(values)

   207

   208

    def select_options (self, key_values, selected_key=None) :

   209

        """

   210

            Render a series of <option> tags for <select>.

   211

   212

            The given key_values is an iterable of (key, value) pairs, key may be None if it's the same as value.

   213

        """

   214

   215

        return '\n'.join(

   216

            '\t<option%s%s>%s</option>' % (

   217

                ' value="%s"' % key if key is not None else '',

   218

                ' selected="selected"' if (key if key is not None else value) == selected_key else '',

   219

                value

   220

            ) for key, value in key_values

   221

        )

   222

   223

    def prev_date (self, date) :

   224

        """

   225

            Returns the previous date for the given datetime-date

   226

        """

   227

   228

        return datetime.datetime(date.year, date.month, date.day, tzinfo=date.tzinfo) - datetime.timedelta(days=1)

   229

   230

    def next_date (self, date) :

   231

        """

   232

            Returns the previous date for the given datetime-date

   233

        """

   234

   235

        return datetime.datetime(date.year, date.month, date.day, tzinfo=date.tzinfo) + datetime.timedelta(days=1)

   236