Example #1
0
 def contains(self, principal):
     user = IPerson(principal, None)
     person = IPerson(self.context)
     for section in self._getSections(person):
         if user in section.instructors:
             return True
     return False
Example #2
0
 def visible(self):
     if not checkPermission("schooltool.edit", self.container):
         return False
     authenticated = IPerson(self.request.principal, None)
     target = IPerson(self.context, None)
     if sameProxiedObjects(authenticated, target):
         return False
     return True
Example #3
0
 def update(self):
     """Process form submission."""
     if 'OVERLAY_MORE' in self.request:
         person = IPerson(self.request.principal)
         url = absoluteURL(person, self.request)
         url += '/calendar_selection.html'
         url += '?nexturl=%s' % urllib.quote(str(self.request.URL))
         self.request.response.redirect(url)
     if 'OVERLAY_APPLY' in self.request:
         person = IPerson(self.request.principal)
         selected = set(self.request.get('overlay', []))
         for item in person.overlaid_calendars:
             item.show = getPath(item.calendar.__parent__) in selected
         url = str(self.request.URL)
         self.request.response.redirect(url)
Example #4
0
    def __call__(self):
        app = ISchoolToolApplication(None)
        person = IPerson(self.request.principal, None)
        if not person:
            raise Unauthorized("Only logged in users can book resources.")
        cal = ISchoolToolCalendar(person)
        if self.request.has_key('event_id'):
            event = cal.find(self.request['event_id'])
        else:
            start_date = self.request.get('start_date')
            start_time = self.request.get('start_time')
            title = self.request.get('title')
            start_datetime = "%s %s" % (start_date, start_time)
            start_datetime = datetime(*strptime(start_datetime,
                                                "%Y-%m-%d %H:%M")[0:6])
            start_datetime = self.timezone.localize(start_datetime)
            start_datetime = start_datetime.astimezone(pytz.UTC)
            duration = timedelta(seconds=int(self.request.get('duration')))
            event = CalendarEvent(dtstart = start_datetime,
                                  duration = duration,
                                  title = title)
            cal.addEvent(event)

        if event:
            resource = app["resources"].get(self.request['resource_id'])
            if resource is not None:
                resource_calendar = ISchoolToolCalendar(resource)
                if not canAccess(resource_calendar, "addEvent"):
                    raise Unauthorized("You don't have the right to"
                                       " book this resource!")
                event.bookResource(resource)
        self.request.response.redirect(self.nextURL(event))
Example #5
0
    def items(self):
        """Return items to be shown in the calendar overlay.

        Does not include "my calendar".

        Each item is a dict with the following keys:

            'title' - title of the calendar

            'calendar' - the calendar object

            'color1', 'color2' - colors assigned to this calendar

            'id' - identifier for form controls

            'checked' - was this item checked for display (either "checked" or
            None)?

        """
        person = IPerson(self.request.principal)
        items = [((item.calendar.title, getPath(item.calendar.__parent__)), {
            'title': item.calendar.title,
            'id': getPath(item.calendar.__parent__),
            'calendar': item.calendar,
            'checked': item.show and "checked" or '',
            'color1': item.color1,
            'color2': item.color2
        }) for item in person.overlaid_calendars
                 if canAccess(item.calendar, '__iter__')]
        items.sort()
        return [i[-1] for i in items]
Example #6
0
 def contains(self, principal):
     person = IPerson(principal, None)
     if person is None:
         return False
     relationships = ContactRelationship.bind(contact=IContact(person))
     is_parent = bool(relationships.any(ACTIVE + PARENT))
     return is_parent
Example #7
0
 def fields(self):
     fields = field.Fields(IPasswordEditForm, ignoreContext=True)
     person = IPerson(self.request.principal)
     if person.username is not self.context.username:
         # Editing someone else's password
         fields = fields.omit('current')
     return fields
Example #8
0
 def size(self):
     size = 0
     for member in self.members:
         if IPerson.providedBy(member):
             size = size + 1
         elif IGroup.providedBy(member):
             size = size + len(member.members)
     return size
Example #9
0
 def size(self):
     size = 0
     for member in self.members:
         if IPerson.providedBy(member):
             size = size + 1
         elif IGroup.providedBy(member):
             size = size + len(member.members)
     return size
Example #10
0
 def contains(self, principal):
     from schooltool.app.browser import same  # XXX
     from schooltool.app.interfaces import ISchoolToolApplication
     from schooltool.person.interfaces import IPerson
     app = ISchoolToolApplication(None)
     persons = app['persons']
     person = IPerson(principal, None)
     return person is not None and same(person, persons.super_user)
Example #11
0
 def child(self):
     target = None
     obj = self.context
     while (target is None and obj is not None):
         target = IPerson(obj, None)
         if target is not None:
             return target
         obj = obj.__parent__
     return target
Example #12
0
 def update(self):
     user = IPerson(self.request.principal)
     super(SendEmailView, self).update()
     if not IContact(user).email:
         url = absoluteURL(self.context, self.request) + \
               '/noTeacherEmail.html'
         self.request.response.redirect(url)
         return
     self.updateDisplayWidgets()
    def __iter__(self):
        if IPerson.providedBy(self.context):
            groups = [group for group in self.context.groups
                      if IGroup.providedBy(group)]
        else:
            groups = list(IGroupContainer(ISchoolToolApplication(None), {}).values())

        for group in sorted(groups, key=lambda g: g.__name__):
            yield GroupTerm(group)
Example #14
0
 def contains(self, principal):
     person = IPerson(principal, None)
     if person is None:
         return False
     target = self.child
     if target is None:
         return False
     relationships = ContactRelationship.bind(contact=IContact(person))
     is_parent = target in relationships.any(ACTIVE + PARENT)
     return is_parent
Example #15
0
 def contains(self, principal):
     int_ids = getUtility(IIntIds)
     principal_id = int_ids.queryId(IPerson(principal, None))
     if principal_id is None:
         return False
     if principal_id == self.context.sender_id:
         return True
     if principal_id in self.context.recipient_ids:
         return True
     return False
Example #16
0
def updateStudentCalendars(event):
    """Add section's calendar to students overlaid calendars."""

    if event.rel_type != URIMembership:
        return

    section = event[URIGroup]

    # Only continue if we're working with Sections rather than generic groups
    if not ISection.providedBy(section):
        return

    member = event[URIMember]

    calendar = ISchoolToolCalendar(section)
    if IRelationshipAddedEvent.providedBy(event):
        if IPerson.providedBy(member) and \
                calendar not in member.overlaid_calendars:
            member.overlaid_calendars.add(calendar)

        elif IGroup.providedBy(member):
            for person in member.members:
                # we don't handle nested groups any more so there
                # shouldn't be more than one layer of groups
                if IPerson.providedBy(person) and \
                       calendar not in person.overlaid_calendars:
                    person.overlaid_calendars.add(calendar)

    elif IRelationshipRemovedEvent.providedBy(event):
        if IPerson.providedBy(member):
            if calendar in member.overlaid_calendars:
                for group in member.groups:
                    if group in section.members:
                        return
                member.overlaid_calendars.remove(calendar)

        elif IGroup.providedBy(member):
            for person in member.members:
                if IPerson.providedBy(person):
                    if calendar in person.overlaid_calendars:
                        if person not in section.members:
                            person.overlaid_calendars.remove(calendar)
def updateStudentCalendars(event):
    """Add section's calendar to students overlaid calendars."""

    if event.rel_type != URIMembership:
        return

    section = event[URIGroup]

    # Only continue if we're working with Sections rather than generic groups
    if not ISection.providedBy(section):
        return

    member = event[URIMember]

    calendar = ISchoolToolCalendar(section)
    if IRelationshipAddedEvent.providedBy(event):
        if IPerson.providedBy(member) and \
                calendar not in member.overlaid_calendars:
            member.overlaid_calendars.add(calendar)

        elif IGroup.providedBy(member):
            for person in member.members:
                # we don't handle nested groups any more so there
                # shouldn't be more than one layer of groups
                if IPerson.providedBy(person) and \
                       calendar not in person.overlaid_calendars:
                    person.overlaid_calendars.add(calendar)

    elif IRelationshipRemovedEvent.providedBy(event):
        if IPerson.providedBy(member):
            if calendar in member.overlaid_calendars:
                for group in member.groups:
                    if group in section.members:
                        return
                member.overlaid_calendars.remove(calendar)

        elif IGroup.providedBy(member):
            for person in member.members:
                if IPerson.providedBy(person):
                    if calendar in person.overlaid_calendars:
                        if person not in section.members:
                            person.overlaid_calendars.remove(calendar)
Example #18
0
 def main_recipient(self):
     person = IPerson(self.request, None)
     if self.context.recipients is None:
         return None
     recipients = sorted(self.context.recipients, key=lambda r: r.__name__)
     if person in recipients:
         return person
     for recipient in recipients:
         if flourish.canView(recipient):
             return recipient
     return None
Example #19
0
 def handle_cancel_action(self, action):
     person = IPerson(self.request.principal, None)
     if person is None:
         worksheet = self.context._getDefaultWorksheet()
     else:
         worksheet = self.context.getCurrentWorksheet(person)
     if worksheet is None:
         url = absoluteURL(self.context.__parent__, self.request)
     else:
         url = absoluteURL(worksheet, self.request) + '/gradebook'
     self.request.response.redirect(url)
Example #20
0
    def getCalendars(self):
        """Get a list of calendars to display.

        Yields tuples (calendar, color1, color2).
        """
        person_calendar = ISchoolToolCalendar(IPerson(self.request.principal))
        resource_calendars = getSelectedResourceCalendars(self.request)
        booking_calendar = createBookingCalendar(person_calendar,
                                                 resource_calendars)
        yield (booking_calendar, '#9db8d2', '#7590ae')
        yield (self.context, '#bfdaf4', '#99b2ce')
Example #21
0
    def __iter__(self):
        if IPerson.providedBy(self.context):
            groups = [
                group for group in self.context.groups
                if IGroup.providedBy(group)
            ]
        else:
            groups = list(
                IGroupContainer(ISchoolToolApplication(None), {}).values())

        for group in sorted(groups, key=lambda g: g.__name__):
            yield GroupTerm(group)
Example #22
0
 def contains(self, principal):
     from schooltool.app.browser import same  # XXX
     app = ISchoolToolApplication(None)
     super_user = app['persons'].super_user
     if self.context.person is super_user:
         person = IPerson(principal, None)
         return same(person, super_user)
     if (ManagersCrowd(self.context.person).contains(principal)
             or ClerksCrowd(self.context.person).contains(principal)):
         return True
     return (ConfigurableCrowd.contains(self, principal)
             and OwnerCrowd(self.context.person).contains(principal))
Example #23
0
    def person(self):
        """Adapt context to IPerson, default to None.

        Sample usage in a page template:

            <a tal:define="person request/principal/schooltool:person"
               tal:condition="person"
               tal:attributes="person/calendar/@@absolute_url">
               My calendar
            </a>

        """
        return IPerson(self.context, None)
Example #24
0
 def update(self):
     """Process forms."""
     if 'CANCEL' in self.request:
         nexturl = self.request.form.get('nexturl')
         if nexturl:
             self.request.response.redirect(nexturl)
         return
     user = IPerson(self.request.principal, None)
     if user is None:
         return
     if 'UPDATE_SUBMIT' in self.request:
         self._updateSelection(user)
         self.message = _('Saved changes.')
         nexturl = self.request.form.get('nexturl')
         if nexturl:
             self.request.response.redirect(nexturl)
Example #25
0
    def getApplicationCalendar(self):
        """Return the application calendar.

        Returns None if the user lacks sufficient permissions.
        """
        user = IPerson(self.request.principal, None)
        if user:
            app = ISchoolToolApplication(None)
            calendar = ISchoolToolCalendar(app)
            if canAccess(calendar, '__iter__'):
                return {
                    'title': app.title,
                    'selected': calendar in user.overlaid_calendars,
                    'calendar': calendar
                }
        return {}
Example #26
0
    def show_overlay(self):
        """Check whether the calendar overlay portlet needs to be rendered.

            >>> from zope.app.testing import setup
            >>> setup.placelessSetUp()
            >>> setup.setUpAnnotations()

            >>> from schooltool.testing import setup as sbsetup
            >>> sbsetup.setUpCalendaring()

        The portlet is only shown when an authenticated user is looking
        at his/her calendar.

        Anonymous user:

            >>> from zope.publisher.browser import TestRequest
            >>> from schooltool.person.person import Person
            >>> request = TestRequest()
            >>> person = Person()
            >>> context = ISchoolToolCalendar(person)
            >>> view = CalendarOverlayView(context, request, None, None)
            >>> view.show_overlay()
            False

        Person that we're looking at

            >>> from schooltool.app.security import Principal
            >>> request.setPrincipal(Principal('id', 'title', person))
            >>> view.show_overlay()
            True

        A different person:

            >>> request.setPrincipal(Principal('id', 'title', Person()))
            >>> view.show_overlay()
            False

       Cleanup:

            >>> setup.placelessTearDown()

        """
        if not ILocation.providedBy(self.context):
            return False
        logged_in = removeSecurityProxy(IPerson(self.request.principal, None))
        calendar_owner = removeSecurityProxy(self.context.__parent__)
        return logged_in is calendar_owner
Example #27
0
    def getCalendars(self, container):
        """List all calendars from a given container."""
        user = removeSecurityProxy(IPerson(self.request.principal, None))
        if user is None:
            return []
        app = ISchoolToolApplication(None)

        result = []
        for obj in app[container].values():
            calendar = ISchoolToolCalendar(obj)
            if obj is not user and canAccess(calendar, '__iter__'):
                result.append({
                    'id': obj.__name__,
                    'title': obj.title,
                    'selected': calendar in user.overlaid_calendars,
                    'calendar': calendar
                })
        return sorted(result, key=lambda item: (item['title'], item['id']))
Example #28
0
 def handle_edit_action(self, action):
     data, errors = self.extractData()
     if errors:
         self.status = self.formErrorsMessage
         return
     writer = IPasswordWriter(self.context)
     writer.setPassword(data['password'])
     person = IPerson(self.request.principal)
     self.status = _('Password changed successfully')
     app = ISchoolToolApplication(None)
     url = '%s/password_changed.html?username=%s'
     url = url % (absoluteURL(app, self.request), self.context.username)
     self.dialog_show = True
     self.dialog_title = translate(self.status, context=self.request)
     self.dialog_url = url
     if person.username is self.context.username:
         auth = getUtility(IAuthentication)
         auth.setCredentials(self.request, person.username,
                             data['password'])
Example #29
0
    def update(self):
        self.person = IPerson(self.request.principal, None)
        if self.person is None:
            # XXX ignas: i had to do this to make the tests pass,
            # someone who knows what this code should do if the user
            # is unauthenticated should add the relevant code
            raise Unauthorized("You don't have the permission to do this.")

        if 'DELETE' in self.request:
            for name in self.request.get('delete', []):
                del self.context[name]
        elif 'form-submitted' in self.request:
            old_pos = 0
            for activity in self.context.values():
                old_pos += 1
                name = getName(activity)
                if 'pos.' + name not in self.request:
                    continue
                new_pos = int(self.request['pos.' + name])
                if new_pos != old_pos:
                    self.context.changePosition(name, new_pos - 1)
Example #30
0
    def getCalendars(self):
        """Get a list of calendars to display.

        Yields tuples (calendar, color1, color2).
        """

        owner = self.context.__parent__

        user = IPerson(self.request.principal, None)
        if (user is not None and sameProxiedObjects(user, owner)):
            return

        instructs = list(
            getRelatedObjects(owner, URISection, rel_type=URIInstruction))
        member_of = list(
            getRelatedObjects(owner, URIGroup, rel_type=URIMembership))

        for obj in instructs + member_of:
            if IHaveSchedule.providedBy(obj):
                cal = ISchoolToolCalendar(obj, None)
                if cal is not None:
                    yield (ISchoolToolCalendar(obj), '#9db8d2', '#7590ae')
Example #31
0
 def contains(self, principal):
     user = IPerson(principal, None)
     person = self.context
     if not IBasicPerson.providedBy(person):
         return False
     return user in person.advisors
Example #32
0
 def user(self):
     return IPerson(self.request.principal, None)
Example #33
0
 def __eq__(self, other):
     if not IPerson.providedBy(other):
         return False
     return self.username == other.username
Example #34
0
 def contains(self, principal):
     return IPerson(principal, None) in self.context.members