5183

pending completion

Build # 5183

Build Type

push

travis-ci

Committed by

theo-o

Commit Message

<a href="https://github.com/tjcsl/ion/commit/<a class=hub.com/tjcsl/ion/commit/1407423515c48633a433ea4b31228ce4b22c778f">140742351<a href="https://github.com/tjcsl/ion/commit/1407423515c48633a433ea4b31228ce4b22c778f">&quot;&gt;Revert &amp;quot;update for seniors&quot;

This reverts commit </a><a class="double-link" href="https://github.com/tjcsl/ion/commit/<a class="double-link" href="https://github.com/tjcsl/ion/commit/c586cd4f4a8061ff71a9b737bac5fd17eaf4c5ca">c586cd4f4</a>">c586cd4f4</a><a href="https://github.com/tjcsl/ion/commit/1407423515c48633a433ea4b31228ce4b22c778f">.

Run Details

817 of 3663 branches covered (22.3%)

6921 of 13420 relevant lines covered (51.57%)

1.03 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

20.39

/intranet/apps/schedule/views.py

import calendar
import logging
from datetime import datetime, timedelta

from dateutil.relativedelta import relativedelta

from django.conf import settings
from django.contrib import messages
from django.contrib.auth.decorators import login_required, user_passes_test
from django.core.cache import cache
from django.http import HttpResponse
from django.shortcuts import get_object_or_404, redirect, render
from django.urls import reverse
from django.utils import timezone
from django.views.decorators.clickjacking import xframe_options_exempt

from ..auth.decorators import deny_restricted
from .forms import DayForm, DayTypeForm
from .models import Block, Day, DayType, Time

logger = logging.getLogger(__name__)
schedule_admin_required = user_passes_test(lambda u: not u.is_anonymous and u.has_admin_permission("schedule"))


def date_format(date):
    try:
        d = date.strftime("%Y-%m-%d")
    except ValueError:
        return None
    return d


def decode_date(date):
    try:
        d = datetime.strptime(date, "%Y-%m-%d")
    except ValueError:
        return None
    return d


def is_weekday(date):
    return date.isoweekday() in range(1, 6)


def schedule_context(request=None, date=None, use_cache=True, show_tomorrow=True):
    monday = 1
    friday = 5
    if request and 'date' in request.GET:
        date = decode_date(request.GET['date'])

    if date is None:
        date = timezone.localtime()

        if is_weekday(date) and date.hour > 17 and show_tomorrow:
            delta = 3 if date.isoweekday() == friday else 1
            date += timedelta(days=delta)
        else:
            while not is_weekday(date):
                date += timedelta(days=1)

    date_fmt = date_format(date)
    key = "bell_schedule:{}".format(date_fmt)
    cached = cache.get(key)
    if cached and use_cache:
        logger.debug("Returning schedule context for %s from cache.", date_fmt)
        return cached
    else:
        try:
            dayobj = Day.objects.select_related("day_type").get(date=date)
            comment = dayobj.comment
        except Day.DoesNotExist:
            dayobj = None
            comment = None

        if dayobj is not None:
            blocks = (dayobj.day_type.blocks.select_related("start", "end").order_by("start__hour", "start__minute"))
        else:
            blocks = []

        try:
            delta = 3 if date.isoweekday() == friday else 1
            date_tomorrow = date_format(date + timedelta(days=delta))

            date_today = date_format(date)

            delta = -3 if date.isoweekday() == monday else -1
            date_yesterday = date_format(date + timedelta(days=delta))
        except OverflowError:
            date_tomorrow = None
            date_yesterday = None
            date_today = None
            schedule_tomorrow = None

        if request and request.user.is_authenticated and request.user.is_eighth_admin:
            try:
                schedule_tomorrow = Day.objects.select_related("day_type").get(date=date_tomorrow)
                logger.debug("tomorrow: %s", schedule_tomorrow)
                if not schedule_tomorrow.day_type:
                    schedule_tomorrow = False
            except Day.DoesNotExist:
                schedule_tomorrow = False
        else:
            schedule_tomorrow = None

        data = {
            "sched_ctx": {
                "dayobj": dayobj,
                "blocks": blocks,
                "date": date,
                "is_weekday": is_weekday(date),
                "date_tomorrow": date_tomorrow,
                "date_today": date_today,
                "date_yesterday": date_yesterday,
                "schedule_tomorrow": schedule_tomorrow,
                "comment": comment
            }
        }
        cache.set(key, data, timeout=settings.CACHE_AGE['bell_schedule'])
        logger.debug("Cached schedule context for %s", date_fmt)
        return data


# does NOT require login


def schedule_view(request):
    data = schedule_context(request)
    return render(request, "schedule/view.html", data)


# does NOT require login


def week_data(request, date=None):
    if request:
        given_date = schedule_context(request)["sched_ctx"]["date"]
        if given_date.isoweekday() not in range(1, 6):
            start_date = given_date + timedelta(days=-given_date.weekday(), weeks=1)
        else:
            start_date = given_date - timedelta(days=given_date.weekday())
    else:
        given_date = date
        if given_date.isoweekday() not in range(1, 6):
            start_date = given_date + timedelta(days=-given_date.weekday(), weeks=1)
        else:
            start_date = given_date - timedelta(days=given_date.weekday())
    days = []
    for i in range(5):
        new_date = start_date + timedelta(days=i)
        days.append(schedule_context(date=new_date))
    next_week = days[-1]["sched_ctx"]["date_tomorrow"]
    last_week = date_format(days[0]["sched_ctx"]["date"] - timedelta(days=7))
    today = date_format(timezone.localtime())
    data = {"days": days, "next_week": next_week, "last_week": last_week, "today": today}
    return data


def month_data(request):
    if request and 'date' in request.GET:
        first_date = decode_date(request.GET['date']) + relativedelta(day=1)
    else:
        first_date = timezone.now() + relativedelta(day=1)
    week1 = week_data(None, first_date)
    week2 = week_data(None, decode_date(week1["next_week"]))
    week3 = week_data(None, decode_date(week2["next_week"]))
    week4 = week_data(None, decode_date(week3["next_week"]))
    week5 = week_data(None, decode_date(week4["next_week"]))
    month = first_date.strftime("%B")
    one_month = relativedelta(months=1)
    next_month = date_format(first_date + one_month)
    last_month = date_format(first_date - one_month)
    data = {"weeks": [week1, week2, week3, week4, week5], "next_month": next_month, "last_month": last_month, "current_month": month}
    return data


@login_required
def calendar_view(request):
    data = {}
    data["week_data"] = week_data(request)
    data["month_data"] = month_data(request)
    if 'view' in request.GET and request.GET["view"] == "month":
        data["view"] = "month"
    else:
        data["view"] = "week"
    return render(request, "schedule/calendar.html", data)

    # does NOT require login


@xframe_options_exempt
def schedule_embed(request):
    data = schedule_context(request)
    return render(request, "schedule/embed.html", data)


# DOES require login


@login_required
def schedule_widget_view(request):
    data = schedule_context(request)
    return render(request, "schedule/widget.html", data)


def get_day_data(firstday, daynum):
    if daynum == 0:
        return {"empty": True}

    date = firstday + timedelta(days=daynum - 1)
    data = {"day": daynum, "formatted_date": date_format(date), "date": date}

    try:
        dayobj = Day.objects.get(date=date)
        data["schedule"] = dayobj.day_type
        data["dayobj"] = dayobj
    except Day.DoesNotExist:
        data["schedule"] = None
        data["dayobj"] = None

    return data


@schedule_admin_required
@deny_restricted
def do_default_fill(request):
    """Change all Mondays to 'Anchor Day' Change all Tuesday/Thursdays to 'Blue Day' Change all
    Wednesday/Fridays to 'Red Day'."""
    monday = 0
    tuesday = 1
    wednesday = 2
    thursday = 3
    friday = 4
    try:
        anchor_day = DayType.objects.get(name="Anchor Day")
        blue_day = DayType.objects.get(name="Blue Day")
        red_day = DayType.objects.get(name="Red Day")
    except DayType.DoesNotExist:
        return render(request, "schedule/fill.html",
                      {"msgs": ["Failed to insert any schedules.", "Make sure you have DayTypes defined for Anchor Days, Blue Days, and Red Days."]})

    daymap = {monday: anchor_day, tuesday: blue_day, wednesday: red_day, thursday: blue_day, friday: red_day}

    msgs = []

    month = request.POST.get("month")
    firstday = datetime.strptime(month, "%Y-%m")

    yr, mn = month.split("-")
    cal = calendar.monthcalendar(int(yr), int(mn))
    for w in cal:
        for d in w:
            day = get_day_data(firstday, d)
            logger.debug(day)

            if "empty" in day:
                continue

            if "schedule" not in day or day["schedule"] is None:
                day_of_week = day["date"].weekday()
                if day_of_week in daymap:
                    type_obj = daymap[day_of_week]

                    day_obj = Day.objects.create(date=day["formatted_date"], day_type=type_obj)
                    msg = "{} is now a {}".format(day["formatted_date"], day_obj.day_type)
                    msgs.append(msg)
    return render(request, "schedule/fill.html", {"msgs": msgs})


def delete_cache():
    cache.delete_pattern("bell_schedule:*")
    logger.debug("Deleted bell schedule cache.")


@schedule_admin_required
@deny_restricted
def admin_home_view(request):
    if "default_fill" in request.POST:
        return do_default_fill(request)

    if "delete_cache" in request.POST:
        delete_cache()
        messages.success(request, "Deleted schedule cache manually")
        return redirect("schedule_admin")

    if "month" in request.GET:
        month = request.GET.get("month")
    elif "schedule_month" in request.session:
        month = request.session["schedule_month"]
    else:
        month = timezone.localtime().strftime("%Y-%m")

    request.session["schedule_month"] = month

    firstday = datetime.strptime(month, "%Y-%m")
    month_name = firstday.strftime("%B")
    year_name = firstday.strftime("%Y")

    yr, mn = month.split("-")
    cal = calendar.monthcalendar(int(yr), int(mn))
    sch = []
    for w in cal:
        week = []
        for d in w:
            week.append(get_day_data(firstday, d))
        sch.append(week)

    add_form = DayForm()

    this_month = firstday.strftime("%Y-%m")
    next_month = (firstday + timedelta(days=31)).strftime("%Y-%m")
    last_month = (firstday + timedelta(days=-31)).strftime("%Y-%m")

    daytypes = DayType.objects.all()

    data = {
        "month_name": month_name,
        "year_name": year_name,
        "sch": sch,
        "add_form": add_form,
        "this_month": this_month,
        "next_month": next_month,
        "last_month": last_month,
        "daytypes": daytypes
    }

    return render(request, "schedule/admin_home.html", data)


@schedule_admin_required
@deny_restricted
def admin_add_view(request):
    if request.method == "POST":
        delete_cache()
        date = request.POST.get("date")
        day = Day.objects.filter(date=date)
        if len(day) <= 1:
            day.delete()
        form = DayForm(request.POST)
        if form.is_valid():
            form.save()
            messages.success(request, "{} is now a {}".format(date, form.cleaned_data["day_type"]))
            return redirect("schedule_admin")
        else:
            messages.success(request, "{} has no schedule assigned".format(date))
            return redirect("schedule_admin")
    else:
        form = DayForm()

    context = {"form": form}
    return render(request, "schedule/admin_add.html", context)


@schedule_admin_required
@deny_restricted
def admin_comment_view(request):
    date = request.GET.get("date")
    if request.method == "POST" and "comment" in request.POST:
        delete_cache()
        date = request.POST.get("date")
        comment = request.POST.get("comment")
        day, _ = Day.objects.get_or_create(date=date)
        day.comment = comment
        day.save()
        return redirect("schedule_admin")
    else:
        try:
            day = Day.objects.get(date=date)
            comment = day.comment
        except Day.DoesNotExist:
            day = None
            comment = None

    context = {"day": day, "date": date, "comment": comment}

    return render(request, "schedule/admin_comment.html", context)


@schedule_admin_required
@deny_restricted
def admin_daytype_view(request, daytype_id=None):
    if request.method == "POST":
        delete_cache()
        if "id" in request.POST:
            daytype_id = request.POST["id"]

            if "make_copy" in request.POST:
                daytype = get_object_or_404(DayType, id=daytype_id)
                blocks = daytype.blocks.all()
                daytype.pk = None
                daytype.name += " (Copy)"
                daytype.save()
                for blk in blocks:
                    daytype.blocks.add(blk)
                daytype.save()

                if "return_url" in request.POST:
                    return HttpResponse(reverse("schedule_daytype", args=[daytype.id]))

                return redirect("schedule_daytype", daytype.id)

            if "delete" in request.POST:
                daytype = get_object_or_404(DayType, id=daytype_id)
                name = "{}".format(daytype)
                daytype.delete()
                messages.success(request, "Deleted {}".format(name))
                return redirect("schedule_admin")

        if daytype_id:
            daytype = get_object_or_404(DayType, id=daytype_id)
            logger.debug("instance: %s", daytype)
            form = DayTypeForm(request.POST, instance=daytype)
        else:
            daytype = None
            form = DayTypeForm(request.POST)
        logger.debug(form)
        logger.debug(request.POST)
        if form.is_valid():
            model = form.save()
            """Add blocks"""
            blocks = zip(
                request.POST.getlist('block_order'), request.POST.getlist('block_name'),
                [[int(j) if j else 0 for j in i.split(":")] if ":" in i else [9, 0] for i in request.POST.getlist('block_start')],
                [[int(j) if j else 0 for j in i.split(":")] if ":" in i else [10, 0] for i in request.POST.getlist('block_end')])
            logger.debug(blocks)
            model.blocks.all().delete()
            for blk in blocks:
                logger.debug(blk)
                start, _ = Time.objects.get_or_create(hour=blk[2][0], minute=blk[2][1])
                end, _ = Time.objects.get_or_create(hour=blk[3][0], minute=blk[3][1])
                bobj, _ = Block.objects.get_or_create(order=blk[0], name=blk[1], start=start, end=end)
                model.blocks.add(bobj)
            model.save()

            if "assign_date" in request.POST:
                assign_date = request.POST.get("assign_date")
                try:
                    dayobj = Day.objects.get(date=assign_date)
                except Day.DoesNotExist:
                    dayobj = Day.objects.create(date=assign_date, day_type=model)
                else:
                    dayobj.day_type = model
                    dayobj.save()
                messages.success(request, "{} is now a {}".format(dayobj.date, dayobj.day_type))

            messages.success(request, "Successfully {} Day Type.".format("modified" if daytype_id else "added"))
            return redirect("schedule_daytype", model.id)
        else:
            messages.error(request, "Error adding Day Type")
    elif daytype_id:
        daytype = get_object_or_404(DayType, id=daytype_id)
        form = DayTypeForm(instance=daytype)
    else:
        daytype = None
        form = DayTypeForm()

    context = {"form": form, "action": "add", "daytype": daytype}

    if "assign_date" in request.GET:
        context["assign_date"] = request.GET.get("assign_date")

    return render(request, "schedule/admin_daytype.html", context)

1	import calendar	2✔
2	import logging	2✔
3	from datetime import datetime, timedelta	2✔
4
5	from dateutil.relativedelta import relativedelta	2✔
6
7	from django.conf import settings	2✔
8	from django.contrib import messages	2✔
9	from django.contrib.auth.decorators import login_required, user_passes_test	2✔
10	from django.core.cache import cache	2✔
11	from django.http import HttpResponse	2✔
12	from django.shortcuts import get_object_or_404, redirect, render	2✔
13	from django.urls import reverse	2✔
14	from django.utils import timezone	2✔
15	from django.views.decorators.clickjacking import xframe_options_exempt	2✔
16
17	from ..auth.decorators import deny_restricted	2✔
18	from .forms import DayForm, DayTypeForm	2✔
19	from .models import Block, Day, DayType, Time	2✔
20
21	logger = logging.getLogger(__name__)	2✔
22	schedule_admin_required = user_passes_test(lambda u: not u.is_anonymous and u.has_admin_permission("schedule"))	2!
23
24
25	def date_format(date):	2✔
26	try:	2✔
27	d = date.strftime("%Y-%m-%d")	2✔
28	except ValueError:	×
29	return None	×
30	return d	2✔
31
32
33	def decode_date(date):	2✔
34	try:	×
35	d = datetime.strptime(date, "%Y-%m-%d")	×
36	except ValueError:	×
37	return None	×
38	return d	×
39
40
41	def is_weekday(date):	2✔
42	return date.isoweekday() in range(1, 6)	2✔
43
44
45	def schedule_context(request=None, date=None, use_cache=True, show_tomorrow=True):	2✔
46	monday = 1	2✔
47	friday = 5	2✔
48	if request and 'date' in request.GET:	2!
49	date = decode_date(request.GET['date'])	×
50
51	if date is None:	2!
52	date = timezone.localtime()	2✔
53
54	if is_weekday(date) and date.hour > 17 and show_tomorrow:	2!
55	delta = 3 if date.isoweekday() == friday else 1	×
56	date += timedelta(days=delta)	×
57	else:
58	while not is_weekday(date):	2!
59	date += timedelta(days=1)	×
60
61	date_fmt = date_format(date)	2✔
62	key = "bell_schedule:{}".format(date_fmt)	2✔
63	cached = cache.get(key)	2✔
64	if cached and use_cache:	2!
65	logger.debug("Returning schedule context for %s from cache.", date_fmt)	×
66	return cached	×
67	else:
68	try:	2✔
69	dayobj = Day.objects.select_related("day_type").get(date=date)	2✔
70	comment = dayobj.comment	×
71	except Day.DoesNotExist:	2✔
72	dayobj = None	2✔
73	comment = None	2✔
74
75	if dayobj is not None:	2!
76	blocks = (dayobj.day_type.blocks.select_related("start", "end").order_by("start__hour", "start__minute"))	×
77	else:
78	blocks = []	2✔
79
80	try:	2✔
81	delta = 3 if date.isoweekday() == friday else 1	2✔
82	date_tomorrow = date_format(date + timedelta(days=delta))	2✔
83
84	date_today = date_format(date)	2✔
85
86	delta = -3 if date.isoweekday() == monday else -1	2✔
87	date_yesterday = date_format(date + timedelta(days=delta))	2✔
88	except OverflowError:	×
89	date_tomorrow = None	×
90	date_yesterday = None	×
91	date_today = None	×
92	schedule_tomorrow = None	×
93
94	if request and request.user.is_authenticated and request.user.is_eighth_admin:	2!
95	try:	×
96	schedule_tomorrow = Day.objects.select_related("day_type").get(date=date_tomorrow)	×
97	logger.debug("tomorrow: %s", schedule_tomorrow)	×
98	if not schedule_tomorrow.day_type:	×
99	schedule_tomorrow = False	×
100	except Day.DoesNotExist:	×
101	schedule_tomorrow = False	×
102	else:
103	schedule_tomorrow = None	2✔
104
105	data = {	2✔
106	"sched_ctx": {
107	"dayobj": dayobj,
108	"blocks": blocks,
109	"date": date,
110	"is_weekday": is_weekday(date),
111	"date_tomorrow": date_tomorrow,
112	"date_today": date_today,
113	"date_yesterday": date_yesterday,
114	"schedule_tomorrow": schedule_tomorrow,
115	"comment": comment
116	}
117	}
118	cache.set(key, data, timeout=settings.CACHE_AGE['bell_schedule'])	2✔
119	logger.debug("Cached schedule context for %s", date_fmt)	2✔
120	return data	2✔
121
122
123	# does NOT require login
124
125
126	def schedule_view(request):	2✔
127	data = schedule_context(request)	×
128	return render(request, "schedule/view.html", data)	×
129
130
131	# does NOT require login
132
133
134	def week_data(request, date=None):	2✔
135	if request:	×
136	given_date = schedule_context(request)["sched_ctx"]["date"]	×
137	if given_date.isoweekday() not in range(1, 6):	×
138	start_date = given_date + timedelta(days=-given_date.weekday(), weeks=1)	×
139	else:
140	start_date = given_date - timedelta(days=given_date.weekday())	×
141	else:
142	given_date = date	×
143	if given_date.isoweekday() not in range(1, 6):	×
144	start_date = given_date + timedelta(days=-given_date.weekday(), weeks=1)	×
145	else:
146	start_date = given_date - timedelta(days=given_date.weekday())	×
147	days = []	×
148	for i in range(5):	×
149	new_date = start_date + timedelta(days=i)	×
150	days.append(schedule_context(date=new_date))	×
151	next_week = days[-1]["sched_ctx"]["date_tomorrow"]	×
152	last_week = date_format(days[0]["sched_ctx"]["date"] - timedelta(days=7))	×
153	today = date_format(timezone.localtime())	×
154	data = {"days": days, "next_week": next_week, "last_week": last_week, "today": today}	×
155	return data	×
156
157
158	def month_data(request):	2✔
159	if request and 'date' in request.GET:	×
160	first_date = decode_date(request.GET['date']) + relativedelta(day=1)	×
161	else:
162	first_date = timezone.now() + relativedelta(day=1)	×
163	week1 = week_data(None, first_date)	×
164	week2 = week_data(None, decode_date(week1["next_week"]))	×
165	week3 = week_data(None, decode_date(week2["next_week"]))	×
166	week4 = week_data(None, decode_date(week3["next_week"]))	×
167	week5 = week_data(None, decode_date(week4["next_week"]))	×
168	month = first_date.strftime("%B")	×
169	one_month = relativedelta(months=1)	×
170	next_month = date_format(first_date + one_month)	×
171	last_month = date_format(first_date - one_month)	×
172	data = {"weeks": [week1, week2, week3, week4, week5], "next_month": next_month, "last_month": last_month, "current_month": month}	×
173	return data	×
174
175
176	@login_required	2✔
177	def calendar_view(request):
178	data = {}	×
179	data["week_data"] = week_data(request)	×
180	data["month_data"] = month_data(request)	×
181	if 'view' in request.GET and request.GET["view"] == "month":	×
182	data["view"] = "month"	×
183	else:
184	data["view"] = "week"	×
185	return render(request, "schedule/calendar.html", data)	×
186
187	# does NOT require login
188
189
190	@xframe_options_exempt	2✔
191	def schedule_embed(request):
192	data = schedule_context(request)	×
193	return render(request, "schedule/embed.html", data)	×
194
195
196	# DOES require login
197
198
199	@login_required	2✔
200	def schedule_widget_view(request):
201	data = schedule_context(request)	×
202	return render(request, "schedule/widget.html", data)	×
203
204
205	def get_day_data(firstday, daynum):	2✔
206	if daynum == 0:	×
207	return {"empty": True}	×
208
209	date = firstday + timedelta(days=daynum - 1)	×
210	data = {"day": daynum, "formatted_date": date_format(date), "date": date}	×
211
212	try:	×
213	dayobj = Day.objects.get(date=date)	×
214	data["schedule"] = dayobj.day_type	×
215	data["dayobj"] = dayobj	×
216	except Day.DoesNotExist:	×
217	data["schedule"] = None	×
218	data["dayobj"] = None	×
219
220	return data	×
221
222
223	@schedule_admin_required	2✔
224	@deny_restricted	2✔
225	def do_default_fill(request):
226	"""Change all Mondays to 'Anchor Day' Change all Tuesday/Thursdays to 'Blue Day' Change all
227	Wednesday/Fridays to 'Red Day'."""
228	monday = 0	×
229	tuesday = 1	×
230	wednesday = 2	×
231	thursday = 3	×
232	friday = 4	×
233	try:	×
234	anchor_day = DayType.objects.get(name="Anchor Day")	×
235	blue_day = DayType.objects.get(name="Blue Day")	×
236	red_day = DayType.objects.get(name="Red Day")	×
237	except DayType.DoesNotExist:	×
238	return render(request, "schedule/fill.html",	×
239	{"msgs": ["Failed to insert any schedules.", "Make sure you have DayTypes defined for Anchor Days, Blue Days, and Red Days."]})
240
241	daymap = {monday: anchor_day, tuesday: blue_day, wednesday: red_day, thursday: blue_day, friday: red_day}	×
242
243	msgs = []	×
244
245	month = request.POST.get("month")	×
246	firstday = datetime.strptime(month, "%Y-%m")	×
247
248	yr, mn = month.split("-")	×
249	cal = calendar.monthcalendar(int(yr), int(mn))	×
250	for w in cal:	×
251	for d in w:	×
252	day = get_day_data(firstday, d)	×
253	logger.debug(day)	×
254
255	if "empty" in day:	×
256	continue	×
257
258	if "schedule" not in day or day["schedule"] is None:	×
259	day_of_week = day["date"].weekday()	×
260	if day_of_week in daymap:	×
261	type_obj = daymap[day_of_week]	×
262
263	day_obj = Day.objects.create(date=day["formatted_date"], day_type=type_obj)	×
264	msg = "{} is now a {}".format(day["formatted_date"], day_obj.day_type)	×
265	msgs.append(msg)	×
266	return render(request, "schedule/fill.html", {"msgs": msgs})	×
267
268
269	def delete_cache():	2✔
270	cache.delete_pattern("bell_schedule:*")	×
271	logger.debug("Deleted bell schedule cache.")	×
272
273
274	@schedule_admin_required	2✔
275	@deny_restricted	2✔
276	def admin_home_view(request):
277	if "default_fill" in request.POST:	×
278	return do_default_fill(request)	×
279
280	if "delete_cache" in request.POST:	×
281	delete_cache()	×
282	messages.success(request, "Deleted schedule cache manually")	×
283	return redirect("schedule_admin")	×
284
285	if "month" in request.GET:	×
286	month = request.GET.get("month")	×
287	elif "schedule_month" in request.session:	×
288	month = request.session["schedule_month"]	×
289	else:
290	month = timezone.localtime().strftime("%Y-%m")	×
291
292	request.session["schedule_month"] = month	×
293
294	firstday = datetime.strptime(month, "%Y-%m")	×
295	month_name = firstday.strftime("%B")	×
296	year_name = firstday.strftime("%Y")	×
297
298	yr, mn = month.split("-")	×
299	cal = calendar.monthcalendar(int(yr), int(mn))	×
300	sch = []	×
301	for w in cal:	×
302	week = []	×
303	for d in w:	×
304	week.append(get_day_data(firstday, d))	×
305	sch.append(week)	×
306
307	add_form = DayForm()	×
308
309	this_month = firstday.strftime("%Y-%m")	×
310	next_month = (firstday + timedelta(days=31)).strftime("%Y-%m")	×
311	last_month = (firstday + timedelta(days=-31)).strftime("%Y-%m")	×
312
313	daytypes = DayType.objects.all()	×
314
315	data = {	×
316	"month_name": month_name,
317	"year_name": year_name,
318	"sch": sch,
319	"add_form": add_form,
320	"this_month": this_month,
321	"next_month": next_month,
322	"last_month": last_month,
323	"daytypes": daytypes
324	}
325
326	return render(request, "schedule/admin_home.html", data)	×
327
328
329	@schedule_admin_required	2✔
330	@deny_restricted	2✔
331	def admin_add_view(request):
332	if request.method == "POST":	×
333	delete_cache()	×
334	date = request.POST.get("date")	×
335	day = Day.objects.filter(date=date)	×
336	if len(day) <= 1:	×
337	day.delete()	×
338	form = DayForm(request.POST)	×
339	if form.is_valid():	×
340	form.save()	×
341	messages.success(request, "{} is now a {}".format(date, form.cleaned_data["day_type"]))	×
342	return redirect("schedule_admin")	×
343	else:
344	messages.success(request, "{} has no schedule assigned".format(date))	×
345	return redirect("schedule_admin")	×
346	else:
347	form = DayForm()	×
348
349	context = {"form": form}	×
350	return render(request, "schedule/admin_add.html", context)	×
351
352
353	@schedule_admin_required	2✔
354	@deny_restricted	2✔
355	def admin_comment_view(request):
356	date = request.GET.get("date")	×
357	if request.method == "POST" and "comment" in request.POST:	×
358	delete_cache()	×
359	date = request.POST.get("date")	×
360	comment = request.POST.get("comment")	×
361	day, _ = Day.objects.get_or_create(date=date)	×
362	day.comment = comment	×
363	day.save()	×
364	return redirect("schedule_admin")	×
365	else:
366	try:	×
367	day = Day.objects.get(date=date)	×
368	comment = day.comment	×
369	except Day.DoesNotExist:	×
370	day = None	×
371	comment = None	×
372
373	context = {"day": day, "date": date, "comment": comment}	×
374
375	return render(request, "schedule/admin_comment.html", context)	×
376
377
378	@schedule_admin_required	2✔
379	@deny_restricted	2✔
380	def admin_daytype_view(request, daytype_id=None):	2✔
381	if request.method == "POST":	×
382	delete_cache()	×
383	if "id" in request.POST:	×
384	daytype_id = request.POST["id"]	×
385
386	if "make_copy" in request.POST:	×
387	daytype = get_object_or_404(DayType, id=daytype_id)	×
388	blocks = daytype.blocks.all()	×
389	daytype.pk = None	×
390	daytype.name += " (Copy)"	×
391	daytype.save()	×
392	for blk in blocks:	×
393	daytype.blocks.add(blk)	×
394	daytype.save()	×
395
396	if "return_url" in request.POST:	×
397	return HttpResponse(reverse("schedule_daytype", args=[daytype.id]))	×
398
399	return redirect("schedule_daytype", daytype.id)	×
400
401	if "delete" in request.POST:	×
402	daytype = get_object_or_404(DayType, id=daytype_id)	×
403	name = "{}".format(daytype)	×
404	daytype.delete()	×
405	messages.success(request, "Deleted {}".format(name))	×
406	return redirect("schedule_admin")	×
407
408	if daytype_id:	×
409	daytype = get_object_or_404(DayType, id=daytype_id)	×
410	logger.debug("instance: %s", daytype)	×
411	form = DayTypeForm(request.POST, instance=daytype)	×
412	else:
413	daytype = None	×
414	form = DayTypeForm(request.POST)	×
415	logger.debug(form)	×
416	logger.debug(request.POST)	×
417	if form.is_valid():	×
418	model = form.save()	×
419	"""Add blocks"""
420	blocks = zip(	×
421	request.POST.getlist('block_order'), request.POST.getlist('block_name'),
422	[[int(j) if j else 0 for j in i.split(":")] if ":" in i else [9, 0] for i in request.POST.getlist('block_start')],
423	[[int(j) if j else 0 for j in i.split(":")] if ":" in i else [10, 0] for i in request.POST.getlist('block_end')])
424	logger.debug(blocks)	×
425	model.blocks.all().delete()	×
426	for blk in blocks:	×
427	logger.debug(blk)	×
428	start, _ = Time.objects.get_or_create(hour=blk[2][0], minute=blk[2][1])	×
429	end, _ = Time.objects.get_or_create(hour=blk[3][0], minute=blk[3][1])	×
430	bobj, _ = Block.objects.get_or_create(order=blk[0], name=blk[1], start=start, end=end)	×
431	model.blocks.add(bobj)	×
432	model.save()	×
433
434	if "assign_date" in request.POST:	×
435	assign_date = request.POST.get("assign_date")	×
436	try:	×
437	dayobj = Day.objects.get(date=assign_date)	×
438	except Day.DoesNotExist:	×
439	dayobj = Day.objects.create(date=assign_date, day_type=model)	×
440	else:
441	dayobj.day_type = model	×
442	dayobj.save()	×
443	messages.success(request, "{} is now a {}".format(dayobj.date, dayobj.day_type))	×
444
445	messages.success(request, "Successfully {} Day Type.".format("modified" if daytype_id else "added"))	×
446	return redirect("schedule_daytype", model.id)	×
447	else:
448	messages.error(request, "Error adding Day Type")	×
449	elif daytype_id:	×
450	daytype = get_object_or_404(DayType, id=daytype_id)	×
451	form = DayTypeForm(instance=daytype)	×
452	else:
453	daytype = None	×
454	form = DayTypeForm()	×
455
456	context = {"form": form, "action": "add", "daytype": daytype}	×
457
458	if "assign_date" in request.GET:	×
459	context["assign_date"] = request.GET.get("assign_date")	×
460
461	return render(request, "schedule/admin_daytype.html", context)	×

tjcsl / ion / 5183

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous