def get_studyperiod(request, studyperiod_id):
studyperiod = get_object_or_404(StudyPeriod, pk=studyperiod_id)
# get the list of subjects for this study period, with a list of
# subject modalities
subject_modalities = {}
for s in Subject.objects.filter(study_period=studyperiod):
subject_modalities[s.name] = dict([(sm.type, sm.planned_hours) for sm in s.modalities.all()])
output = dict(
[
(type, {"name": dict(SubjectModality.TYPE_CHOICES)[type], "data": []})
for type, null in SubjectModality.TYPE_CHOICES
]
)
for (subject, modalities) in subject_modalities.items():
for key, value in modalities.items():
output[key]["data"].append(int(value))
final_output = []
for key, value in output.items():
final_output.append(value)
return render_to_response(
"get_studyperiod.html",
{"studyperiod": studyperiod, "series": final_output, "subjects": subject_modalities.keys()},
request,
)
def display_campus_mgr_calendar(request):
user_form = UserEventForm(prefix="user")
my_selector_form = MySelectorForm(prefix="my_selector", what=["my_user"])
return render_to_response('calendar.html', {
'campus_form': campus_form,
'user_form': user_form,
'classgroup_form': classgroup_form,
'classgroup_selector_form': classgroup_selector_form,
'campus_selector_form': campus_selector_form,
'my_selector_form': my_selector_form,
}, request)
def add_classgroup(request, campus_id=None):
if request.POST:
form = ClassGroupForm(data=request.POST)
if form.is_valid():
form.save()
return redirect('profiles:list_classgroups')
else:
form = ClassGroupForm({'campus':campus_id})
return render_to_response("add_classgroup.html", {
'form': form,
}, request)
def list_events(request):
to_fetch = ("mandatory", "my_user", "my_classgroup", "my_campus",
"my_university")
events = set()
start_date = datetime.now()
end_date = datetime.now()+timedelta(days=7)
for source in to_fetch:
fetched = When.objects.user_planning(request.user, source,
start_date, end_date)
for event in list(fetched):
event.resource = source
events = events | set(fetched)
return render_to_response('list_events.html', {'whens' : events,} , request)
def update_event(request, when_id):
form = None
when = get_object_or_404(When, pk=when_id)
event_type, who = when.event.get_type()
data = {'name' : when.event.name,
'date' : when.date.strftime("%Y-%m-%d"),
'start_hour' : int(when.date.strftime("%H")),
'duration' : int(when.event.duration),
'place_text' : when.event.place_text,
'force_display' : when.event.force_display,
}
if event_type == 'classgroup' and\
request.user.get_profile().can_manage_classgroup(who.classgroup.id):
data.update({'place' : when.event.places.get().id,
'classgroup' :
who.classgroup.id,
'modality' :
when.event.subject_modality.type,
'subject' :
when.event.subject_modality.subject.id, })
if request.POST:
form = ClassgroupEventForm(user=request.user, data=request.POST)
else:
form = ClassgroupEventForm(user=request.user, initial=data)
elif event_type == 'user' and\
who.user == request.user:
if request.POST:
form = UserEventForm(data=request.POST)
else:
form = UserEventForm(initial=data)
elif event_type == 'campus' and\
request.user.get_profile().can_manage_cursus(who.campus.id):
try:
place_id = when.event.places.get().id
except ObjectDoesNotExist:
place_id = None
data.update({'place' : place_id,
'campus' : who.campus.id,
})
if request.POST:
form = CampusEventForm(data=request.POST, user=request.user)
else:
form = CampusEventForm(initial=data, user=request.user)
if request.POST:
if form.is_valid():
when = form.save(when)
j = when.to_fullcalendar_dict(lambda when:True, "moved")
return HttpResponse(json.dumps(j))
return render_to_response('edit_user_calendar.html', {
'form': form,}, request)
def display_ical_mgmnt(request):
ical_feeds = []
nical_feeds = []
ical_feeds.append(("my_user", None, "My calendar"))
if request.user.get_profile().can_manage_campus():
for campus in Campus.objects.get_managed_by(request.user):
ical_feeds.append(("campus", campus.id, campus.name))
for classgroup in ClassGroup.objects.get_managed_by(request.user):
ical_feeds.append(("classgroup", classgroup.id, classgroup.name))
else:
ical_feeds.append(("my_classgroup", None, "My class"))
ical_feeds.append(("my_campus", None, "My campus"))
for type, id, name in ical_feeds:
hash = get_ical_link_hash(request, type, id).hash
if id is None:
id = ''
nical_feeds.append((type, id, name, hash))
return render_to_response('display_ical_mgmnt.html',
{ 'feeds': nical_feeds,}, request)
def display_calendar(request):
#Standard forms
user_form = UserEventForm(prefix="user")
my_selector_form = MySelectorForm(prefix="my_selector")
forms = { 'user_form': user_form,}
selectors = {'my_selector_form': my_selector_form,}
if request.user.get_profile().can_manage_campus():
forms['campus_form'] = CampusEventForm(prefix="campus",
user=request.user)
forms['classgroup_form'] = ClassgroupEventForm(prefix="classgroup",
user=request.user)
selectors['campus'] = CampusSelectorForm(
prefix="cmp_selector", user=request.user)
selectors['classgroup'] = ClassgroupSelectorForm(
prefix="cg_selector", user=request.user)
selectors['my_selector_form'] = MySelectorForm(prefix="my_selector",
what=["my_user"])
forms.update(selectors)
return render_to_response('calendar.html', {'forms' : forms,} , request)
def list(request, fields, model=None, queryset=None, form_class=None,
template=DEFAULT_LIST_TEMPLATE, object_name=None, app_name=None,
object_verbose_name=None, rights={},
acl_handler=DEFAULT_ACL_HANDLER, extra_context={}, *args,
**kwargs):
"""A generic List method, that allows to specify the list of what we want
to display.
You could either pass a model or a queryset to loop on.
This view also display a creation form, if a form is provided and the user
has the rights to do so.
The rights are defined with the right arguments, wich is a dict.
This is mainly used to know if the current user can do CRUD actions.
If these are not defined, list uses the acl_handler, if given, to
determine wich rights to set for the current user. If not defined, this
callable use DEFAULT_ACL_HANDLER.
By default, the list action use a template defined by
DEFAULT_LIST_TEMPLATE, but you can change this behavior by setting the
`template` parameter.
"""
if model is None and queryset is not None:
model = queryset.model
if model:
model, form_class = get_model_and_form_class(model, form_class)
if queryset is None:
queryset = model.objects.all()
queryset = queryset._clone()
list_params = {}
if queryset:
for obj in queryset:
list_params[obj.id] = []
for (key, attrs) in fields:
item = obj
for attr in attrs.split('.'):
if hasattr(item, attr):
item = getattr(item, attr)
if callable(item):
try:
item = item()
except Exception:
item = ""
else:
item = ""
list_params[obj.id].append((key, item))
try:
if object_name is None:
object_name = model.__name__.lower()
if app_name is None:
app_name = model.__module__.split('.')[0]
except AttributeError:
object_name, app_name = None, None
#Gruik
if request.is_ajax():
return HttpResponse(json.dumps([dict(list_params[m])
for m in list_params]))
return_context = {
'elements': list_params,
'object_name': object_name,
'app_name': app_name,
'object_verbose_name': object_verbose_name or object_name,
'form': form_class(),
}
return_context = _process_rights(request, acl_handler, return_context,
rights, *args, **kwargs)
# add extra_context
for key, value in extra_context.items():
return_context[key] = value
return render_to_response(template, return_context, request)
