1

"""

     2

    Calendar view of orders

     3

"""

     4

     5

from svv.controllers import PageHandler

     6

from svv.html import tags

     7

from svv import database as db

     8

from svv import html

     9

    10

    11

import datetime

    12

import calendar

    13

import logging

    14

    15

log = logging.getLogger('svv.cal')

    16

    17

class CalendarView (PageHandler) :

    18

    """

    19

        Single-month calendar view with events for given month shown

    20

    """

    21

    22

    # first date of week

    23

    FIRST_WEEKDAY = 0

    24

    25

    # year/month format for URLs

    26

    URL_FORMAT = "%Y-%m"

    27

    28

    # formatting styles

    29

    MONTH_TITLE_FORMAT = "%B %Y"

    30

    31

    @classmethod

    32

    def dayofweek_title (cls, dow) :

    33

        """

    34

            Return day of week name for given dow number

    35

        """

    36

    37

        return calendar.day_name[dow]

    38

    39

    @classmethod

    40

    def _wrap_year (cls, year, month) :

    41

        """

    42

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

    43

    44

            Returns (year, month)

    45

        """

    46

    47

        # underflow?

    48

        if month == 0 :

    49

            # wrap to previous year

    50

            return (year - 1, 12)

    51

    52

        # overflow?

    53

        elif month == 13 :

    54

            # wrap to next year

    55

            return (year + 1, 1)

    56

    57

        # sane value

    58

        elif 1 <= month <= 12 :

    59

            return (year, month)

    60

    61

        # insane value

    62

        else :

    63

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

    64

    65

    @classmethod

    66

    def prev_month (cls, month) :

    67

        """

    68

            Compute date for previous month.

    69

        """

    70

    71

        # normalize

    72

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

    73

    74

        return datetime.date(y, m, 1)

    75

    76

    @classmethod

    77

    def next_month (cls, month) :

    78

        """

    79

            Compute date for following month.

    80

        """

    81

    82

        # normalize

    83

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

    84

    85

        return datetime.date(y, m, 1)

    86

    87

    88

    def process (self, **foo) :

    89

        """

    90

            Setup

    91

        """

    92

    93

        # db session

    94

        self.session = self.app.session()

    95

    96

    def render_day_header (self, month, date) :

    97

        """

    98

            Render <th> for day

    99

        """

   100

   101

        today = datetime.date.today()

   102

   103

        classes = []

   104

   105

        if (date.year, date.month) == (month.year, month.month) :

   106

            # current month

   107

            classes.append('in-month')

   108

   109

        else :

   110

            classes.append('out-month')

   111

   112

        if date == today :

   113

            classes.append('today')

   114

   115

        class_ = ' '.join(classes)

   116

   117

        return tags.th(date.day, class_=class_)

   118

   119

    def get_events_for_interval (self, start, end) :

   120

        """

   121

            Return full list of all Orders taking place during the given datetime interval, ordered by start time

   122

        """

   123

   124

        # XXX: bad imports

   125

        from orders import Order

   126

   127

        return self.session.query(Order).filter(

   128

                (Order.event_start.between(start, end))

   129

            |   (Order.event_end.between(start, end))

   130

            |   (db.between(start, Order.event_start, Order.event_end))

   131

        ).order_by(Order.event_start).all()

   132

   133

    def interval_for_dates (self, dates) :

   134

        """

   135

            Returns a datetime (start, end) interval encompassing all of the given dates

   136

        """

   137

   138

        # a day is 00:00:00 - 23:59:59

   139

        start = datetime.datetime.combine(min(dates), datetime.time(0, 0, 0))

   140

        end = datetime.datetime.combine(max(dates), datetime.time(23, 59, 59))

   141

   142

        return start, end

   143

   144

    def hours_from_day_start (self, dt) :

   145

        """

   146

            Return the number of hours from the start of the day to the given datetime, as a float.

   147

        """

   148

   149

        HOUR = float(60 * 60)

   150

   151

        # dt - 00:00:00

   152

        return (dt - dt.replace(hour=0, minute=0, second=0)).seconds / HOUR

   153

   154

    def hours_to_day_end (self, dt) :

   155

        """

   156

            Return the number of hours from the given datetime to the day's end, as a float.

   157

        """

   158

   159

        HOUR = float(60 * 60)

   160

   161

        # 23:59:59 - dt

   162

        return (dt.replace(hour=23, minute=59, second=59) - dt).seconds / HOUR

   163

   164

    def render_week (self, month, week) :

   165

        """

   166

            Render day rows for given week.

   167

        """

   168

   169

        # XXX: nasty

   170

        from svv import urls

   171

   172

        # week as datetime interval

   173

        week_start, week_end = self.interval_for_dates(week)

   174

   175

        # all orders for week

   176

        orders = self.get_events_for_interval(week_start, week_end)

   177

   178

        # day headers

   179

        yield tags.tr(class_='week-header')(

   180

            self.render_day_header(month, date) for date in week

   181

        )

   182

   183

        # each event on its own row for now

   184

        for order in orders :

   185

            # start/end date for this week

   186

            start_day = min(date for date in week if order.on_date(date))

   187

            end_day = max(date for date in week if order.on_date(date))

   188

   189

            # as vector into week

   190

            leading_days = (start_day - min(week)).days

   191

            length_days = (end_day - start_day).days + 1

   192

            trailing_days = (max(week) - end_day).days

   193

   194

            # continues prev/next week?

   195

            prev_week = (start_day > order.event_start.date())

   196

            next_week = (end_day < order.event_end.date())

   197

   198

            log.debug("Event %r from %r -> %r", order.event_name, start_day, end_day)

   199

   200

            # spec class

   201

            classes = ' '.join(cls for cls in (

   202

                'event',

   203

                'continues-prev' if prev_week else None,

   204

                'continues-next' if next_week else None,

   205

            ) if cls)

   206

   207

            # compute dynamic styles

   208

            styles = []

   209

   210

            # width of each hour in the event's span this week, as a percentage

   211

            hour_width = 100.0 / (length_days * 24)

   212

   213

            # margin for start hour offset

   214

            if not prev_week :

   215

                # starts on this week, so calc how many hours into day

   216

                styles.append('margin-left: %d%%' % int(hour_width * self.hours_from_day_start(order.event_start)))

   217

   218

            # margin for end hour offset

   219

            if not next_week :

   220

                # ends on this week, se calc how many hours until day end

   221

                styles.append('margin-right: %d%%' % int(hour_width * self.hours_to_day_end(order.event_end)))

   222

   223

            # style spec

   224

            if styles :

   225

                style = '; '.join(styles)

   226

   227

            else :

   228

                style = None

   229

   230

            yield tags.tr(class_='week-data')(

   231

                ([tags.td("")] * leading_days),

   232

                tags.td(colspan=length_days, class_=classes)(

   233

                    tags.a(href=self.url_for(urls.OrderView, id=order.id), style=style)(

   234

                        tags.div(class_='arrow-left')("") if prev_week else None,

   235

                        order.event_name,

   236

                        tags.div(class_='arrow-right')("") if next_week else None,

   237

                    )

   238

                ),

   239

                ([tags.td("")] * trailing_days),

   240

            )

   241

   242

    def render_calendar (self, month) :

   243

        """

   244

            Render calendar for given date's month.

   245

        """

   246

   247

        cal = calendar.Calendar(self.FIRST_WEEKDAY)

   248

   249

        # next/prev month

   250

        prev = self.prev_month(month)

   251

        next = self.next_month(month)

   252

   253

        return tags.table(class_='calendar')(

   254

            tags.caption(

   255

                tags.a(href=self.url_for(CalendarView, yearmonth=prev.strftime(self.URL_FORMAT)), class_='prev-month')(

   256

                    html.raw("«")

   257

                ),

   258

                month.strftime(self.MONTH_TITLE_FORMAT),

   259

                tags.a(href=self.url_for(CalendarView, yearmonth=next.strftime(self.URL_FORMAT)), class_='next-month')(

   260

                    html.raw("»")

   261

                ),

   262

            ),

   263

   264

            # would be useful for borders, but too hard to style

   265

            #(tags.col() for dow in cal.iterweekdays()),

   266

   267

            # week-day headers

   268

            tags.thead(

   269

                tags.tr(

   270

                    tags.th(

   271

                        self.dayofweek_title(dow)

   272

                    ) for dow in cal.iterweekdays()

   273

                )

   274

            ),

   275

   276

            # month weeks

   277

            tags.tbody(

   278

                (

   279

                    self.render_week(month, week)

   280

                ) for week in cal.monthdatescalendar(month.year, month.month)

   281

            ),

   282

        )

   283

   284

    def render_content (self, yearmonth=None) :

   285

        """

   286

            Render calendar HTML for given year/month.

   287

        """

   288

   289

        if yearmonth :

   290

            # requested month

   291

            month = datetime.datetime.strptime(yearmonth, self.URL_FORMAT).date()

   292

   293

        else :

   294

            # this month

   295

            month = datetime.date.today()

   296

   297

        return (

   300

            self.render_calendar(month),

   301

        )

   302