1

"""

     2

    Some additional helpers

     3

"""

     4

     5

import datetime

     6

import calendar as _calendar

     7

     8

import qmsk.web.helpers

     9

    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

    34

    def tz_name (self, tz) :

    35

        """

    36

            Returns a string describing the given timezone

    37

        """

    38

    39

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

    40

    41

    def fmt_month (self, date) :

    42

        """

    43

            Formats a month

    44

        """

    45

    46

        return date.strftime(config.MONTH_FMT)

    47

    48

    def fmt_weekday (self, wday) :

    49

        """

    50

            Formats an abbreviated weekday name

    51

        """

    52

    53

        return _calendar.day_abbr[wday]

    54

    55

    def build_date (self, month, mday) :

    56

        """

    57

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

    58

        """

    59

    60

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

    61

    62

    def now (self) :

    63

        """

    64

            Build current time

    65

        """

    66

    67

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

    68

    69

    def today (self) :

    70

        """

    71

            Build today's date

    72

        """

    73

    74

        return self.now().date()

    75

    76

    def is_today (self, dt) :

    77

        """

    78

            Checks if the given datetime.datetime is today

    79

        """

    80

    81

        # compare with current date

    82

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

    83

    84

    def is_this_month (self, month) :

    85

        """

    86

            Checks the given month is the current month

    87

        """

    88

    89

        today = self.today()

    90

    91

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

    92

    93

    @staticmethod

    94

    def _wrap_year (year, month) :

    95

        """

    96

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

    97

    98

            Returns (year, month)

    99

        """

   100

   101

        # underflow?

   102

        if month == 0 :

   103

            # wrap to previous year

   104

            return (year - 1, 12)

   105

   106

        # overflow?

   107

        elif month == 13 :

   108

            # wrap to next year

   109

            return (year + 1, 1)

   110

   111

        # sane value

   112

        elif 1 <= month <= 12 :

   113

            return (year, month)

   114

   115

        # insane value

   116

        else :

   117

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

   118

   119

    def prev_month (self, month) :

   120

        """

   121

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

   122

        """

   123

   124

        # previous month

   125

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

   126

   127

        # build datetime

   128

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

   129

   130

    def next_month (self, month) :

   131

        """

   132

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

   133

        """

   134

   135

        # previous month

   136

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

   137

   138

        # build datetime

   139

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

   140

   141

    def fmt_time (self, time=None) :

   142

        """

   143

            Format given time, or current time

   144

        """

   145

   146

        # defaults

   147

        if not time :

   148

            time = self.now()

   149

   150

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

   151

   152

    def fmt_date (self, date=None) :

   153

        """

   154

            Format given date, or current date

   155

        """

   156

   157

        # defaults

   158

        if not date :

   159

            date = self.now()

   160

   161

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

   162

   163

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

   164

        """

   165

            Build URL with our request object

   166

        """

   167

   168

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

   169

   170

    # old name

   171

    build_url = url

   172

   173

    def utc_timestamp (self, dtz) :

   174

        """

   175

            Build an UTC timestamp from the given datetime

   176

        """

   177

   178

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

   179

   180

    def skip_next (self, count, skip) :

   181

        """

   182

            Return skip offset for next page

   183

        """

   184

   185

        return count + skip

   186

   187

    def skip_page (self, count, page) :

   188

        """

   189

            Skip to page

   190

        """

   191

   192

        if page :

   193

            return count * page

   194

   195

        else :

   196

            return None

   197

   198

    def skip_prev (self, count, skip) :

   199

        """

   200

            Return skip offset for previous page, None for first page

   201

        """

   202

   203

        if skip > count :

   204

            return skip - count

   205

   206

        else :

   207

            return None

   208

   209

    def max (self, *values) :

   210

        """

   211

            Returns the largest of the given values

   212

        """

   213

   214

        return max(values)

   215

   216

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

   217

        """

   218

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

   219

   220

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

   221

        """

   222

   223

        return '\n'.join(

   224

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

   225

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

   226

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

   227

                value

   228

            ) for key, value in key_values

   229

        )

   230

   231

    def prev_date (self, date) :

   232

        """

   233

            Returns the previous date for the given datetime-date

   234

        """

   235

   236

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

   237

   238

    def next_date (self, date) :

   239

        """

   240

            Returns the previous date for the given datetime-date

   241

        """

   242

   243

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

   244