Esempio n. 1
0
def homepage_project_json(request, project, can_edit):
    the_json = {}
    the_json['id'] = project.id
    the_json['title'] = project.title
    the_json['url'] = project.get_absolute_url()
    
    participants = project.attribution_list()
    the_json['authors'] = [{
        'name': get_public_name(u, request),
        'last': idx == (len(participants) - 1) 
    } for idx, u in enumerate(participants)]
    the_json['modified'] = project.modified.strftime("%m/%d/%y %I:%M %p")
    the_json['status'] = project.status()
    the_json['editable'] = can_edit
    
    feedback = project.feedback_discussion()
    if feedback:
        the_json['feedback'] = feedback.id
        
    parent_assignment = project.assignment()
    if parent_assignment:    
        the_json['collaboration'] = {}
        the_json['collaboration']['title'] = parent_assignment.title
        the_json['collaboration']['url'] = parent_assignment.get_absolute_url()
        
    return the_json
Esempio n. 2
0
    def all_responses(self, request, project):
        ctx = []
        responses = project.responses(request.course, request.user)

        for response in responses:
            submitted = ''
            if response.is_submitted():
                submitted = response.date_submitted.strftime(self.date_fmt)

            obj = {
                'url': response.get_absolute_url(),
                'title': response.title,
                'submitted': submitted,
                'modified': response.modified.strftime(self.date_fmt),
                'attribution_list': []}

            last = len(response.attribution_list()) - 1
            for idx, author in enumerate(response.attribution_list()):
                obj['attribution_list'].append({
                    'name': get_public_name(author, request),
                    'last': idx == last})

            ctx.append(obj)

        return sorted(
            ctx,
            key=lambda response: response['attribution_list'][0]['name'])
Esempio n. 3
0
def project_json(request,project):
        #bad language, we should change this to user_of_assets or something
    space_viewer = request.user 
    if request.GET.has_key('as') and request.user.is_staff:
        space_viewer = get_object_or_404(User, username=request.GET['as'])
        
    rand = ''.join([choice(letters) for i in range(5)])

    data = {'project':{'title':project.title,
                       'body':project.body,
                       'participants':[{'name':p.get_full_name(),
                                        'username':p.username,
                                        'public_name': get_public_name(p, request),
                                        'is_viewer': space_viewer.username == p.username,  
                                        } for p in project.participants.all()],
                       'id':project.pk,
                       'url':project.get_absolute_url(),
                       'username':request.user.username,
                       },
            'assets':dict([('%s_%s' % (rand,ann.asset.pk),
                            ann.asset.sherd_json(request)
                            ) for ann in project.citations()
                           if ann.title != "Annotation Deleted"
                           ]),
            'annotations':[ann.sherd_json(request, rand, ('title','author') )
                           for ann in project.citations()
                           ],
            'type':'project',
            }
    return HttpResponse(simplejson.dumps(data, indent=2), mimetype='application/json')
Esempio n. 4
0
    def all_responses(self, request, project):
        ctx = []
        responses = project.responses(request.course, request.user)

        for response in responses:
            submitted = ''
            if response.is_submitted():
                submitted = response.date_submitted.strftime(self.date_fmt)

            obj = {
                'url': response.get_absolute_url(),
                'title': response.title,
                'submitted': submitted,
                'modified': response.modified.strftime(self.date_fmt),
                'attribution_list': []
            }

            last = len(response.attribution_list()) - 1
            for idx, author in enumerate(response.attribution_list()):
                obj['attribution_list'].append({
                    'name':
                    get_public_name(author, request),
                    'last':
                    idx == last
                })

            ctx.append(obj)

        return sorted(
            ctx, key=lambda response: response['attribution_list'][0]['name'])
Esempio n. 5
0
def homepage_project_json(request, project, can_edit):
    the_json = {}
    the_json['id'] = project.id
    the_json['title'] = project.title
    the_json['url'] = project.get_absolute_url()

    participants = project.attribution_list()
    the_json['authors'] = [{
        'name': get_public_name(u, request),
        'last': idx == (len(participants) - 1)
    } for idx, u in enumerate(participants)]
    the_json['modified'] = project.modified.strftime("%m/%d/%y %I:%M %p")
    the_json['status'] = project.status()
    the_json['editable'] = can_edit

    feedback = project.feedback_discussion()
    if feedback:
        the_json['feedback'] = feedback.id

    parent_assignment = project.assignment()
    if parent_assignment:
        the_json['collaboration'] = {}
        the_json['collaboration']['title'] = parent_assignment.title
        the_json['collaboration']['url'] = parent_assignment.get_absolute_url()

    return the_json
Esempio n. 6
0
    def dehydrate(self, bundle):
        bundle.data["is_assignment"] = bundle.obj.visibility_short() == "Assignment"
        bundle.data["is_response"] = bundle.obj.assignment() is not None
        bundle.data["attribution"] = bundle.obj.attribution()
        bundle.data["url"] = bundle.obj.get_absolute_url()
        bundle.data["due_date"] = bundle.obj.get_due_date()
        bundle.data["modified_date"] = bundle.obj.modified.strftime("%m/%d/%y")
        bundle.data["modified_time"] = bundle.obj.modified.strftime("%I:%M %p")
        bundle.data["editable"] = self.editable
        bundle.data["is_faculty"] = self.is_viewer_faculty

        participants = bundle.obj.attribution_list()
        bundle.data["participants"] = [
            {
                "name": p.get_full_name(),
                "username": p.username,
                "public_name": get_public_name(p, bundle.request),
                "is_viewer": self.record_viewer == p.username,
                "last": idx == (len(participants) - 1),
            }
            for idx, p in enumerate(participants)
        ]
        bundle.data["status"] = bundle.obj.status()

        for key, value in self.extras.items():
            bundle.data[key] = value

        return bundle
Esempio n. 7
0
    def create_course(self, form, affil):
        # Create the course.
        studentaffil = re.sub(r'\.fc\.', '.st.', affil.name)
        g = Group.objects.get_or_create(name=studentaffil)[0]
        fg = Group.objects.get_or_create(name=affil.name)[0]

        c = Course.objects.create(
            group=g,
            faculty_group=fg,
            title=form.cleaned_data.get('course_name'))

        # Add the current user as an instructor.
        c.group.user_set.add(self.request.user)
        c.faculty_group.user_set.add(self.request.user)
        c.add_detail('instructor',
                     get_public_name(self.request.user, self.request))

        # Get the year and term from the affil string.
        affil_dict = {}
        if hasattr(settings, 'COURSEAFFILS_COURSESTRING_MAPPER'):
            affil_dict = settings.COURSEAFFILS_COURSESTRING_MAPPER.to_dict(
                affil.name)
        if affil_dict:
            c.info.year = affil_dict.get('year')
            c.info.term = affil_dict.get('term')
            c.info.save()

        return c
Esempio n. 8
0
    def dehydrate(self, bundle):
        bundle.data['is_assignment'] = bundle.obj.is_assignment()
        bundle.data['is_selection_assignment'] = \
            bundle.obj.is_selection_assignment()
        bundle.data['description'] = bundle.obj.description()
        bundle.data['is_response'] = bundle.obj.assignment() is not None
        bundle.data['attribution'] = bundle.obj.attribution()
        bundle.data['url'] = bundle.obj.get_absolute_url()
        bundle.data['due_date'] = bundle.obj.get_due_date()
        bundle.data['modified_date'] = bundle.obj.modified.strftime("%m/%d/%y")
        bundle.data['modified_time'] = bundle.obj.modified.strftime("%I:%M %p")
        bundle.data['editable'] = self.editable
        bundle.data['is_faculty'] = self.is_viewer_faculty
        bundle.data['submitted'] = bundle.obj.is_submitted()

        participants = bundle.obj.attribution_list()
        bundle.data['participants'] = [{
            'name': p.get_full_name(),
            'username': p.username,
            'public_name': get_public_name(p, bundle.request),
            'is_viewer': self.record_viewer == p.username,
            'last': idx == (len(participants) - 1)
        } for idx, p in enumerate(participants)]
        bundle.data['status'] = bundle.obj.status()

        for key, value in self.extras.items():
            bundle.data[key] = value

        return bundle
Esempio n. 9
0
    def dehydrate(self, bundle):
        bundle.data['is_assignment'] = \
            bundle.obj.visibility_short() == 'Assignment'
        bundle.data['is_response'] = bundle.obj.assignment() is not None
        bundle.data['attribution'] = bundle.obj.attribution()
        bundle.data['url'] = bundle.obj.get_absolute_url()
        bundle.data['due_date'] = bundle.obj.get_due_date()
        bundle.data['modified_date'] = bundle.obj.modified.strftime("%m/%d/%y")
        bundle.data['modified_time'] = bundle.obj.modified.strftime("%I:%M %p")
        bundle.data['editable'] = self.editable
        bundle.data['is_faculty'] = self.is_viewer_faculty

        participants = bundle.obj.attribution_list()
        bundle.data['participants'] = [{
            'name':
            p.get_full_name(),
            'username':
            p.username,
            'public_name':
            get_public_name(p, bundle.request),
            'is_viewer':
            self.record_viewer == p.username,
            'last':
            idx == (len(participants) - 1)
        } for idx, p in enumerate(participants)]
        bundle.data['status'] = bundle.obj.status()

        for key, value in self.extras.items():
            bundle.data[key] = value

        return bundle
Esempio n. 10
0
def browse_sources(request):
    c = request.course

    user = request.user
    archives = []
    upload_archive = None
    for a in c.asset_set.archives().order_by('title'):
        archive = a.sources['archive']
        thumb = a.sources.get('thumb',None)
        description = a.metadata().get('description','')
        uploader = a.metadata().get('upload', 0)
        
        archive_context = {
            "id":a.id,
            "title":a.title,
            "thumb":(None if not thumb else {"id":thumb.id, "url":thumb.url}),
            "archive":{"id":archive.id, "url":archive.url},
            #is description a list or a string?
            "metadata": (description[0] if hasattr(description,'append') else description)
        }
        
        if (uploader[0] if hasattr(uploader,'append') else uploader):
            upload_archive = archive_context
        else:
            archives.append(archive_context)
        
    archives.sort(key=operator.itemgetter('title'))
    
    owners = []
    if in_course(user.username, request.course) and (user.is_staff or user.has_perm('assetmgr.can_upload_for')):
        owners = [{ 'username': m.username, 'public_name': get_public_name(m, request) } for m in request.course.members]
        
    rv = {"archives":archives,
          "upload_archive": upload_archive,
          "is_faculty":c.is_faculty(user),
          "space_viewer":user,
          'newsrc':request.GET.get('newsrc', ''),
          'can_upload': course_details.can_upload(request.user, request.course),
          'upload_service': getattr(settings,'UPLOAD_SERVICE',None),
          "help_browse_sources": UserSetting.get_setting(user, "help_browse_sources", True),
          "help_no_sources": UserSetting.get_setting(user, "help_no_sources", True),
          'msg': request.GET.get('msg', ''),
          'owners': owners, 
          }
    if not rv['archives']:
        rv['faculty_assets'] = [a for a in Asset.objects.filter(c.faculty_filter).order_by('added')
                                if a not in rv['archives'] ]

    if getattr(settings,'DJANGOSHERD_FLICKR_APIKEY',None):
        # MUST only contain string values for now!! 
        # (see templates/assetmgr/bookmarklet.js to see why or fix)
        rv['bookmarklet_vars'] = {'flickr_apikey':settings.DJANGOSHERD_FLICKR_APIKEY }
        
    
    return rv
Esempio n. 11
0
def homepage_project_json(request, projects, can_edit):
    project_json = []

    for project in projects:
        the_json = {}
        the_json['id'] = project.id
        the_json['title'] = project.title
        the_json['url'] = project.get_absolute_url()
        the_json['due_date'] = project.get_due_date()

        participants = project.attribution_list()
        the_json['authors'] = [{
            'name': get_public_name(u, request),
            'last': idx == (len(participants) - 1)
        } for idx, u in enumerate(participants)]
        the_json['modified_date'] = project.modified.strftime("%m/%d/%y")
        the_json['modified_time'] = project.modified.strftime("%I:%M %p")
        the_json['status'] = project.status()
        the_json['editable'] = can_edit

        if can_edit:
            feedback = project.feedback_discussion()
            if feedback:
                the_json['feedback'] = feedback.id

        parent_assignment = project.assignment()
        if parent_assignment:
            the_json['collaboration'] = {}
            the_json['collaboration']['title'] = parent_assignment.title
            the_json['collaboration']['url'] = \
                parent_assignment.get_absolute_url()
            the_json['collaboration']['due_date'] = \
                parent_assignment.get_due_date()

        is_assignment = project.is_assignment(request)
        if is_assignment:
            count = 0
            for response in project.responses(request):
                if response.can_read(request):
                    count += 1
            the_json['responses'] = count

        the_json['display_as_assignment'] = \
            is_assignment or parent_assignment is not None

        if is_assignment:
            the_json['is_assignment'] = True
            the_json['responses'] = len(project.responses(request))

        project_json.append(the_json)

    return project_json
Esempio n. 12
0
def homepage_project_json(request, projects, can_edit):
    project_json = []

    for project in projects:
        the_json = {}
        the_json['id'] = project.id
        the_json['title'] = project.title
        the_json['url'] = project.get_absolute_url()
        the_json['due_date'] = project.get_due_date()

        participants = project.attribution_list()
        the_json['authors'] = [{
            'name': get_public_name(u, request),
            'last': idx == (len(participants) - 1)
        } for idx, u in enumerate(participants)]
        the_json['modified_date'] = project.modified.strftime("%m/%d/%y")
        the_json['modified_time'] = project.modified.strftime("%I:%M %p")
        the_json['status'] = project.status()
        the_json['editable'] = can_edit

        if can_edit:
            feedback = project.feedback_discussion()
            if feedback:
                the_json['feedback'] = feedback.id

        parent_assignment = project.assignment()
        if parent_assignment:
            the_json['collaboration'] = {}
            the_json['collaboration']['title'] = parent_assignment.title
            the_json['collaboration']['url'] = \
                parent_assignment.get_absolute_url()
            the_json['collaboration']['due_date'] = \
                parent_assignment.get_due_date()

        is_assignment = project.is_assignment(request)
        if is_assignment:
            count = 0
            for r in project.responses(request):
                if r.can_read(request):
                    count += 1
            the_json['responses'] = count

        the_json['display_as_assignment'] = \
            is_assignment or parent_assignment is not None

        if is_assignment:
            the_json['is_assignment'] = True
            the_json['responses'] = len(project.responses(request))

        project_json.append(the_json)

    return project_json
Esempio n. 13
0
    def dehydrate(self, bundle):
        bundle.data['is_essay_assignment'] = bundle.obj.is_essay_assignment()
        bundle.data['is_selection_assignment'] = \
            bundle.obj.is_selection_assignment()
        bundle.data['is_sequence_assignment'] = \
            bundle.obj.is_sequence_assignment()
        bundle.data['is_sequence'] = bundle.obj.is_sequence()
        bundle.data['description'] = bundle.obj.description()
        bundle.data['is_response'] = bundle.obj.assignment() is not None
        bundle.data['attribution'] = bundle.obj.attribution()

        if hasattr(self, 'request') and \
           waffle.flag_is_active(self.request, 'addressable_courses') and \
           hasattr(self.request, 'course'):

            bundle.data['url'] = reverse('project-workspace',
                                         kwargs={
                                             'course_pk':
                                             self.request.course.pk,
                                             'project_id': bundle.obj.pk,
                                         })
        else:
            bundle.data['url'] = bundle.obj.get_absolute_url()

        bundle.data['due_date'] = bundle.obj.get_due_date()
        bundle.data['modified_date'] = bundle.obj.modified.strftime("%m/%d/%y")
        bundle.data['modified_time'] = bundle.obj.modified.strftime("%I:%M %p")
        bundle.data['editable'] = self.editable
        bundle.data['is_faculty'] = self.is_viewer_faculty
        bundle.data['submitted'] = bundle.obj.is_submitted()

        participants = bundle.obj.attribution_list()
        bundle.data['participants'] = [{
            'name':
            p.get_full_name(),
            'username':
            p.username,
            'public_name':
            get_public_name(p, bundle.request),
            'is_viewer':
            self.record_viewer == p.username,
            'last':
            idx == (len(participants) - 1)
        } for idx, p in enumerate(participants)]
        bundle.data['status'] = bundle.obj.status()

        for key, value in self.extras.items():
            bundle.data[key] = value

        return bundle
Esempio n. 14
0
    def render_one(self, request, project, version_number=None):
        bundle = self.build_bundle(obj=project, request=request)
        dehydrated = self.full_dehydrate(bundle)
        project_ctx = self._meta.serializer.to_simple(dehydrated, None)
        project_ctx['body'] = project.body
        project_ctx['public_url'] = project.public_url()
        project_ctx['current_version'] = version_number
        project_ctx['visibility'] = project.visibility_short()

        project_type = ('assignment'
                        if project.is_assignment(request.course, request.user)
                        else 'composition')
        project_ctx['type'] = project_type

        assets, notes = self.related_assets_notes(request, project)

        data = {
            'project': project_ctx,
            'type': 'project',
            'can_edit': self.editable,
            'annotations': notes,
            'assets': assets
        }

        data['responses'] = self.all_responses(request, project)
        data['response_count'] = len(data['responses'])

        my_responses = self.my_responses(request, project)
        if len(my_responses) == 1:
            data['my_response'] = my_responses[0]
        elif len(my_responses) > 1:
            data['my_responses'] = my_responses
            data['my_responses_count'] = len(my_responses)

        if project.is_participant(request.user):
            data['revisions'] = [{
                'version_number': v.version_number,
                'versioned_id': v.versioned_id,
                'author': get_public_name(v.instance().author, request),
                'modified': v.modified.strftime("%m/%d/%y %I:%M %p")}
                for v in project.versions.order_by('-change_time')]

        if self.editable:
            projectform = ProjectForm(request, instance=project)
            data['form'] = {
                'participants': projectform['participants'].__unicode__(),
                'publish': projectform['publish'].__unicode__()
            }

        return data
Esempio n. 15
0
def project_revisions(request, project_id):
    project = get_object_or_404(Project, pk=project_id, course=request.course)

    if not project.is_participant(request.user):
        return HttpResponseForbidden("forbidden")

    data = {}
    data['revisions'] = [{
        'version_number': v.version_number,
        'versioned_id': v.versioned_id,
        'author': get_public_name(v.instance().author, request),
        'modified': v.modified.strftime("%m/%d/%y %I:%M %p")}
        for v in project.versions.order_by('-change_time')]

    return HttpResponse(simplejson.dumps(data, indent=2),
                        mimetype='application/json')
Esempio n. 16
0
def project_revisions(request, project_id):
    project = get_object_or_404(Project, pk=project_id, course=request.course)

    if not project.is_participant(request.user):
        return HttpResponseForbidden("forbidden")

    data = {}
    data['revisions'] = [{
        'version_number': v.version_number,
        'versioned_id': v.versioned_id,
        'author': get_public_name(v.instance().author, request),
        'modified': v.modified.strftime("%m/%d/%y %I:%M %p")}
        for v in project.versions.order_by('-change_time')]

    return HttpResponse(json.dumps(data, indent=2),
                        mimetype='application/json')
Esempio n. 17
0
    def init_created_course(self, course, affil):
        # Add the current user as an instructor.
        course.group.user_set.add(self.request.user)
        course.faculty_group.user_set.add(self.request.user)
        course.add_detail('instructor',
                          get_public_name(self.request.user, self.request))

        # Get the year and term from the affil string.
        affil_dict = {}
        if hasattr(settings, 'COURSEAFFILS_COURSESTRING_MAPPER'):
            affil_dict = settings.COURSEAFFILS_COURSESTRING_MAPPER.to_dict(
                affil.name)
        if affil_dict:
            course.info.year = affil_dict.get('year')
            course.info.term = affil_dict.get('term')
            course.info.save()
Esempio n. 18
0
    def init_created_course(self, course, affil):
        # Add the current user as an instructor.
        course.group.user_set.add(self.request.user)
        course.faculty_group.user_set.add(self.request.user)
        course.add_detail('instructor',
                          get_public_name(self.request.user, self.request))

        # Get the year and term from the affil string.
        affil_dict = {}
        if hasattr(settings, 'COURSEAFFILS_COURSESTRING_MAPPER'):
            affil_dict = settings.COURSEAFFILS_COURSESTRING_MAPPER.to_dict(
                affil.name)
        if affil_dict:
            course.info.year = affil_dict.get('year')
            course.info.term = affil_dict.get('term')
            course.info.save()
Esempio n. 19
0
    def get_context_data(self, **kwargs):
        ctx = super().get_context_data(**kwargs)
        ctx['project'] = self.project
        ctx['versions'] = []

        fmt = "%m/%d/%y %I:%M %p"
        for v in self.project.versions():
            author = User.objects.get(id=v.field_dict['author_id'])
            ctx['versions'].append({
                'modified':
                v.revision.date_created.strftime(fmt),
                'author':
                get_public_name(author, self.request),
                'version_number':
                v.revision_id
            })
        return ctx
Esempio n. 20
0
    def __init__(self, request, *args, **kwargs):
        super(ProjectForm, self).__init__(*args, **kwargs)

        lst = [(u.id, get_public_name(u, request))
               for u in request.course.user_set.all()]
        self.fields['participants'].choices = sorted(
            lst, key=lambda participant: participant[1])
        self.fields['participants'].widget.attrs = {
            'id': "id_participants_%s" % self.instance.id
        }

        col = kwargs['instance'].collaboration()
        if col:
            pol = col._policy.policy_name
            if pol not in dict(self.fields['publish'].choices):
                self.fields['publish'].choices.append((pol, pol))
            self.initial['publish'] = pol

        if request.course.is_faculty(request.user):
            # Faculty
            self.fields['publish'].choices = \
                [choice for choice in self.fields['publish'].choices
                 if choice[0] in PUBLISH_OPTIONS_FACULTY]
        else:
            # Student
            if kwargs['instance'].assignment():
                # Assignment response
                self.fields['publish'].choices = \
                    [choice for choice in self.fields['publish'].choices
                     if choice[0] in PUBLISH_OPTIONS_STUDENT_ASSIGNMENT]
            else:
                self.fields['publish'].choices = \
                    [choice for choice in self.fields['publish'].choices
                     if choice[0] in PUBLISH_OPTIONS_STUDENT_COMPOSITION]

        if course_details.allow_public_compositions(request.course):
            self.fields['publish'].choices.append(PUBLISH_OPTIONS_PUBLIC)

        self.fields['participants'].required = False
        self.fields['body'].required = False
        self.fields['submit'].required = False
        self.fields['publish'].required = False

        # for structured collaboration
        self.fields['title'].widget.attrs['maxlength'] = 80
Esempio n. 21
0
    def __init__(self, request, *args, **kwargs):
        super(ProjectForm, self).__init__(*args, **kwargs)

        lst = [(u.id, get_public_name(u, request))
               for u in request.course.user_set.all()]
        self.fields['participants'].choices = sorted(
            lst, key=lambda participant: participant[1])
        self.fields['participants'].widget.attrs = {
            'id': "id_participants_%s" % self.instance.id
        }

        col = kwargs['instance'].collaboration()
        if col:
            pol = col._policy.policy_name
            if pol not in dict(self.fields['publish'].choices):
                self.fields['publish'].choices.append((pol, pol))
            self.initial['publish'] = pol

        if request.course.is_faculty(request.user):
            # Faculty
            self.fields['publish'].choices = \
                [choice for choice in self.fields['publish'].choices
                 if choice[0] in PUBLISH_OPTIONS_FACULTY]
        else:
            # Student
            if kwargs['instance'].assignment():
                # Assignment response
                self.fields['publish'].choices = \
                    [choice for choice in self.fields['publish'].choices
                     if choice[0] in PUBLISH_OPTIONS_STUDENT_ASSIGNMENT]
            else:
                self.fields['publish'].choices = \
                    [choice for choice in self.fields['publish'].choices
                     if choice[0] in PUBLISH_OPTIONS_STUDENT_COMPOSITION]

        if course_details.allow_public_compositions(request.course):
            self.fields['publish'].choices.append(PUBLISH_OPTIONS_PUBLIC)

        self.fields['participants'].required = False
        self.fields['body'].required = False
        self.fields['submit'].required = False
        self.fields['publish'].required = False

        # for structured collaboration
        self.fields['title'].widget.attrs['maxlength'] = 80
Esempio n. 22
0
def project_revisions(request, project_id):
    project = get_object_or_404(Project, pk=project_id, course=request.course)

    if not project.is_participant(request.user):
        return HttpResponseForbidden("forbidden")

    data = {}
    data["revisions"] = [
        {
            "version_number": v.version_number,
            "versioned_id": v.versioned_id,
            "author": get_public_name(v.instance().author, request),
            "modified": v.modified.strftime("%m/%d/%y %I:%M %p"),
        }
        for v in project.versions.order_by("-change_time")
    ]

    return HttpResponse(simplejson.dumps(data, indent=2), mimetype="application/json")
Esempio n. 23
0
    def my_responses(self, request, project):
        my_responses = []
        for response in project.responses_by(request.course, request.user,
                                             request.user):
            obj = {'url': response.get_absolute_url(),
                   'title': response.title,
                   'modified': response.modified.strftime(self.date_fmt),
                   'attribution_list': []}

            last = len(response.attribution_list()) - 1
            for idx, author in enumerate(response.attribution_list()):
                obj['attribution_list'].append({
                    'name': get_public_name(author, request),
                    'last': idx == last})

            my_responses.append(obj)

        return my_responses
Esempio n. 24
0
def project_revisions(request, project_id):
    project = get_object_or_404(Project, pk=project_id, course=request.course)

    if not project.is_participant(request.user):
        return HttpResponseForbidden("forbidden")

    data = {'revisions': []}
    fmt = "%m/%d/%y %I:%M %p"
    for v in project.versions():
        author = User.objects.get(id=v.field_dict['author'])
        data['revisions'].append({
            'version_number': v.revision_id,
            'versioned_id': v.object_id,
            'author': get_public_name(author, request),
            'modified': v.revision.date_created.strftime(fmt)
        })

    return HttpResponse(json.dumps(data, indent=2),
                        content_type='application/json')
Esempio n. 25
0
def project_revisions(request, project_id):
    project = get_object_or_404(Project, pk=project_id, course=request.course)

    if not project.is_participant(request.user):
        return HttpResponseForbidden("forbidden")

    data = {'revisions': []}
    fmt = "%m/%d/%y %I:%M %p"
    for v in project.versions():
        author = User.objects.get(id=v.field_dict['author_id'])
        data['revisions'].append({
            'version_number': v.revision_id,
            'versioned_id': v.object_id,
            'author': get_public_name(author, request),
            'modified': v.revision.date_created.strftime(fmt)
        })

    return HttpResponse(json.dumps(data, indent=2),
                        content_type='application/json')
Esempio n. 26
0
    def __init__(self, request, *args, **kwargs):
        super(ProjectForm, self).__init__(*args, **kwargs)

        lst = [(u.id, get_public_name(u, request))
               for u in request.course.user_set.all()]
        self.fields['participants'].choices = sorted(
            lst, key=lambda participant: participant[1])
        self.fields['participants'].widget.attrs = {
            'id': "id_participants_%s" % self.instance.id
        }

        project = kwargs['instance']
        if project:
            # set initial publish value
            col = project.get_collaboration()
            if col:
                self.initial['publish'] = col.policy_record.policy_name
        else:
            self.instance = None

        choices = self.get_choices(request, project)
        self.fields['publish'].choices = choices

        # response view policy. limit choices if there is no project
        # or the project is a selection assignment
        if (not project or not (
                project.is_composition() or project.is_sequence())):
            choices = [RESPONSE_VIEW_NEVER]
            if all_selections_are_visible(request.course):
                choices.append(RESPONSE_VIEW_SUBMITTED)
                choices.append(RESPONSE_VIEW_ALWAYS)
            self.fields['response_view_policy'].choices = choices

        self.fields['participants'].required = False
        self.fields['body'].required = False
        self.fields['submit'].required = False
        self.fields['publish'].required = False

        # for structured collaboration
        self.fields['title'].widget.attrs['maxlength'] = 80
Esempio n. 27
0
    def __init__(self,request, *args, **kwargs):
        super(ProjectForm,self).__init__(*args,**kwargs)
        self.fields['participants'].widget = widgets.FilteredSelectMultiple("participants",False) 
        
        lst = [(u.id,get_public_name(u, request)) for u in request.course.user_set.all()]
        self.fields['participants'].choices = sorted(lst, key=lambda participant: participant[1])   # sort by name
        
        
        col = kwargs['instance'].collaboration()
        if col:
            pol = col._policy.policy_name
            if pol not in dict(self.fields['publish'].choices):
                self.fields['publish'].choices.append( (pol,pol) )
            self.initial['publish'] = pol
        
        if not request.course.is_faculty(request.user):
            self.fields['publish'].choices = [choice for choice in self.fields['publish'].choices
                                              if choice[0] not in PUBLISH_OPTIONS_FACULTY_ONLY]

        if not course_details.allow_public_compositions(request.course):
            self.fields['publish'].choices = [choice for choice in self.fields['publish'].choices
                                              if choice[0] not in PUBLISH_OPTIONS_PUBLIC]
            
        
        #not restrictive enough -- people can add children to their own projects
        # is that a good idea?
        # necessary to add a discussion to it, but maybe that's a workaround
        # how about we just have people 'create' a project from the assignment page for now.
        #self.fields['parent'].choices = [(sc.id,sc.title) for sc in 
        #                                 Collaboration.objects.filter(context=request.collaboration_context,
        #                                                              content_type = ContentType.objects.get_for_model(Project))
        #                                 if sc.permission_to('add_child',request)
        #                                 ]
            

        self.fields['participants'].required = False
        self.fields['body'].required = False
        self.fields['submit'].required = False
        self.fields['publish'].required = False
        self.fields['title'].widget.attrs['maxlength'] = 80 #for structured collaboration
Esempio n. 28
0
    def __init__(self, request, *args, **kwargs):
        super(ProjectForm, self).__init__(*args, **kwargs)

        lst = [(u.id, get_public_name(u, request))
               for u in request.course.user_set.all()]
        self.fields['participants'].choices = sorted(
            lst, key=lambda participant: participant[1])
        self.fields['participants'].widget.attrs = {
            'id': "id_participants_%s" % self.instance.id
        }

        project = kwargs['instance']
        if project:
            # set initial publish value
            col = project.get_collaboration()
            if col:
                self.initial['publish'] = col.policy_record.policy_name
        else:
            self.instance = None

        choices = self.get_choices(request, project)
        self.fields['publish'].choices = choices

        # response view policy. limit choices if there is no project
        # or the project is a selection assignment
        if (not project
                or not (project.is_composition() or project.is_sequence())):
            choices = [RESPONSE_VIEW_NEVER]
            if all_selections_are_visible(request.course):
                choices.append(RESPONSE_VIEW_SUBMITTED)
                choices.append(RESPONSE_VIEW_ALWAYS)
            self.fields['response_view_policy'].choices = choices

        self.fields['participants'].required = False
        self.fields['body'].required = False
        self.fields['submit'].required = False
        self.fields['publish'].required = False

        # for structured collaboration
        self.fields['title'].widget.attrs['maxlength'] = 80
Esempio n. 29
0
    def my_responses(self, request, project):
        ctx = []
        responses = project.responses(request.course, request.user,
                                      request.user)
        for response in responses:
            obj = {
                'url': response.get_absolute_url(),
                'title': response.title,
                'modified': response.modified.strftime(self.date_fmt),
                'attribution_list': []
            }

            last = len(response.attribution_list()) - 1
            for idx, author in enumerate(response.attribution_list()):
                obj['attribution_list'].append({
                    'name':
                    get_public_name(author, request),
                    'last':
                    idx == last
                })

            ctx.append(obj)

        return ctx
Esempio n. 30
0
    def __init__(self,request, *args, **kwargs):
        super(ProjectForm,self).__init__(*args,**kwargs)
        self.fields['participants'].widget = widgets.FilteredSelectMultiple("participants",False) 
        
        lst = [(u.id,get_public_name(u, request)) for u in request.course.user_set.all()]
        self.fields['participants'].choices = sorted(lst, key=lambda participant: participant[1])   # sort by name
        
        
        col = kwargs['instance'].collaboration()
        if col:
            pol = col._policy.policy_name
            if pol not in dict(self.fields['publish'].choices):
                self.fields['publish'].choices.append( (pol,pol) )
            self.initial['publish'] = pol

        if not request.course.is_faculty(request.user):
            self.fields['publish'].choices = [choice for choice in self.fields['publish'].choices
                                              if choice[0] not in PUBLISH_OPTIONS_FACULTY_ONLY]
            
        
        #not restrictive enough -- people can add children to their own projects
        # is that a good idea?
        # necessary to add a discussion to it, but maybe that's a workaround
        # how about we just have people 'create' a project from the assignment page for now.
        #self.fields['parent'].choices = [(sc.id,sc.title) for sc in 
        #                                 Collaboration.objects.filter(context=request.collaboration_context,
        #                                                              content_type = ContentType.objects.get_for_model(Project))
        #                                 if sc.permission_to('add_child',request)
        #                                 ]
            

        self.fields['participants'].required = False
        self.fields['body'].required = False
        self.fields['submit'].required = False
        self.fields['publish'].required = False
        self.fields['title'].widget.attrs['maxlength'] = 80 #for structured collaboration
Esempio n. 31
0
def get_records(request, record_owner, projects, assignments, assets):
    course = request.course
    logged_in_user = request.user
    
    # Can the record_owner edit the records
    viewing_my_records = (record_owner == logged_in_user)
    viewing_faculty_records = record_owner and course.is_faculty(record_owner)

    # Allow the logged in user to add assets to his composition 
    citable = request.GET.has_key('citable') and request.GET.get('citable') == 'true'
    
    # Is the current user faculty OR staff
    is_faculty = course.is_faculty(logged_in_user)
    
    # Does the course allow viewing other user selections?
    owner_selections_are_visible = course_details.all_selections_are_visible(course) or \
        viewing_my_records or viewing_faculty_records or is_faculty
        
    # Filter the assets 
    for fil in filter_by:
        filter_value = request.GET.get(fil)
        if filter_value:
            assets = [asset for asset in assets
                      if filter_by[fil](asset, filter_value, record_owner)]
    
    active_filters = get_active_filters(request, filter_by)
    
    # Spew out json for the assets 
    asset_json = []
    options = {
        'owner_selections_are_visible': request.GET.has_key('annotations') and owner_selections_are_visible,
        'all_selections_are_visible': course_details.all_selections_are_visible(course) or is_faculty,
        'can_edit': viewing_my_records,
        'citable': citable
    }
            
    for asset in assets:
        asset_json.append(homepage_asset_json(request, asset, logged_in_user, record_owner, options))
        
    # Spew out json for the projects
    project_json = []
    for p in projects:
        project_json.append(homepage_project_json(request, p, viewing_my_records))
        
    # Tags
    tags = []
    if record_owner:
        if owner_selections_are_visible:
            # Tags for selected user
            tags = Tag.objects.usage_for_queryset(
                record_owner.sherdnote_set.filter(asset__course=course),
                counts=True)
    else:
        if owner_selections_are_visible:
            # Tags for the whole class
            tags = Tag.objects.usage_for_queryset(
                SherdNote.objects.filter(asset__course=course),
                counts=True)
        else:
            # Tags for myself and faculty members
            tags = Tag.objects.usage_for_queryset(
                       logged_in_user.sherdnote_set.filter(asset__course=course),
                       counts=True)
            
            for f in course.faculty:
                tags.extend(Tag.objects.usage_for_queryset(
                                f.sherdnote_set.filter(asset__course=course),
                                counts=True))
    

    tags.sort(lambda a, b:cmp(a.name.lower(), b.name.lower()))

    # Assemble the context
    data = { 'assets': asset_json,
             'assignments' : [ {'id': a.id, 'url': a.get_absolute_url(), 'title': a.title, 'modified': a.modified.strftime("%m/%d/%y %I:%M %p")} for a in assignments],
             'projects' : project_json,
             'tags': [ { 'name': tag.name } for tag in tags ],
             'active_filters': active_filters,
             'space_viewer'  : { 'username': logged_in_user.username, 'public_name': get_public_name(logged_in_user, request), 'can_manage': (logged_in_user.is_staff and not record_owner) },
             'editable' : viewing_my_records,
             'citable' : citable,
             'owners' : [{ 'username': m.username, 'public_name': get_public_name(m, request) } for m in request.course.members],
             'compositions' : len(projects) > 0 or len(assignments) > 0,
             'is_faculty': is_faculty,
            }
    
    if record_owner:
        data['space_owner'] = { 'username': record_owner.username, 'public_name': get_public_name(record_owner, request) }

    json_stream = simplejson.dumps(data, indent=2)
    return HttpResponse(json_stream, mimetype='application/json')
Esempio n. 32
0
    def render_one(self, request, project, version_number=None):
        bundle = self.build_bundle(obj=project, request=request)
        dehydrated = self.full_dehydrate(bundle)
        project_ctx = self._meta.serializer.to_simple(dehydrated, None)
        project_ctx['body'] = project.body
        project_ctx['public_url'] = project.public_url()
        project_ctx['current_version'] = version_number
        project_ctx['visibility'] = project.visibility_short()
        project_ctx['type'] = ('assignment' if project.is_assignment(request)
                               else 'composition')

        rand = ''.join([choice(letters) for i in range(5)])

        asset_resource = AssetResource()
        sherd_resource = SherdNoteResource()

        assets = {}
        notes = []
        for note in project.citations():
            notes.append(sherd_resource.render_one(request, note, rand))
            if (note.title not in ["Annotation Deleted", 'Asset Deleted']):
                key = '%s_%s' % (rand, note.asset.pk)
                if key not in assets.keys():
                    assets[key] = \
                        asset_resource.render_one(request, note.asset)

        data = {
            'project': project_ctx,
            'type': 'project',
            'can_edit': self.editable,
            'annotations': notes,
            'assets': assets
        }

        data['responses'] = []
        for response in project.responses(request):
            if response.can_read(request):
                obj = {
                    'url': response.get_absolute_url(),
                    'title': response.title,
                    'modified': response.modified.strftime(self.date_fmt),
                    'attribution_list': []
                }

                last = len(response.attribution_list()) - 1
                for idx, author in enumerate(response.attribution_list()):
                    obj['attribution_list'].append({
                        'name':
                        get_public_name(author, request),
                        'last':
                        idx == last
                    })

                data['responses'].append(obj)
        data['response_count'] = len(data['responses'])

        my_responses = []
        for response in project.responses_by(request, request.user):
            obj = {
                'url': response.get_absolute_url(),
                'title': response.title,
                'modified': response.modified.strftime(self.date_fmt),
                'attribution_list': []
            }

            last = len(response.attribution_list()) - 1
            for idx, author in enumerate(response.attribution_list()):
                obj['attribution_list'].append({
                    'name':
                    get_public_name(author, request),
                    'last':
                    idx == last
                })

            my_responses.append(obj)

        if len(my_responses) == 1:
            data['my_response'] = my_responses[0]
        elif len(my_responses) > 1:
            data['my_responses'] = my_responses
            data['my_responses_count'] = len(my_responses)

        if project.is_participant(request.user):
            data['revisions'] = [{
                'version_number':
                v.version_number,
                'versioned_id':
                v.versioned_id,
                'author':
                get_public_name(v.instance().author, request),
                'modified':
                v.modified.strftime("%m/%d/%y %I:%M %p")
            } for v in project.versions.order_by('-change_time')]

        if self.editable:
            projectform = ProjectForm(request, instance=project)
            data['form'] = {
                'participants': projectform['participants'].__unicode__(),
                'publish': projectform['publish'].__unicode__()
            }

        return data
Esempio n. 33
0
 def render(self, context):
     user_s = self.vars['user'].resolve(context)
     if self.truncate is not None:
         user_s = user_s[:self.truncate]
     return get_public_name(user_s, context['request'])
Esempio n. 34
0
 def dehydrate(self, bundle):
     bundle.data["public_name"] = get_public_name(bundle.obj, bundle.request)
     return bundle
Esempio n. 35
0
def composition_project_json(request, project, can_edit, version_number=None):
    '''
        JSON representation for a project. Includes:
        * basic project information
        * assets
        * annotations
        * responses (if applicable & permissable)
        * revisions (if permissable)
        * a project participant form (if permissable)
    '''

    rand = ''.join([choice(letters) for i in range(5)])

    versions = project.versions.order_by('-change_time')
    participants = project.attribution_list()
    is_assignment = project.is_assignment(request)

    data = {
        'project': {
            'id':
            project.pk,
            'title':
            project.title,
            'url':
            project.get_absolute_url(),
            'body':
            project.body,
            'participants': [{
                'name': p.get_full_name(),
                'username': p.username,
                'public_name': get_public_name(p, request),
                'is_viewer': request.user.username == p.username,
                'last': idx == (len(participants) - 1)
            } for idx, p in enumerate(participants)],
            'public_url':
            project.public_url(),
            'visibility':
            project.visibility_short(),
            'username':
            request.user.username,
            'type':
            'assignment' if is_assignment else 'composition',
            'current_version':
            version_number if version_number else None,
            'create_selection':
            is_assignment,
            'is_assignment':
            is_assignment
        },
        'assets':
        dict([('%s_%s' % (rand, ann.asset.pk), ann.asset.sherd_json(request))
              for ann in project.citations()
              if ann.title != "Annotation Deleted"
              and ann.title != 'Asset Deleted']),
        'annotations': [
            ann.sherd_json(request, rand, ('title', 'author'))
            for ann in project.citations()
        ],
        'type':
        'project',
        'can_edit':
        can_edit,
    }

    data['responses'] = []
    for r in project.responses(request):
        if r.can_read(request):
            obj = {
                'url': r.get_absolute_url(),
                'title': r.title,
                'modified': r.modified.strftime("%m/%d/%y %I:%M %p"),
                'attribution_list': []
            }

            x = len(r.attribution_list()) - 1
            for idx, author in enumerate(r.attribution_list()):
                obj['attribution_list'].append({
                    'name':
                    get_public_name(author, request),
                    'last':
                    idx == x
                })

            data['responses'].append(obj)
    data['response_count'] = len(data['responses'])

    my_responses = []
    for r in project.responses_by(request, request.user):
        obj = {
            'url': r.get_absolute_url(),
            'title': r.title,
            'modified': r.modified.strftime("%m/%d/%y %I:%M %p"),
            'attribution_list': []
        }

        x = len(r.attribution_list()) - 1
        for idx, author in enumerate(r.attribution_list()):
            obj['attribution_list'].append({
                'name':
                get_public_name(author, request),
                'last':
                idx == x
            })

        my_responses.append(obj)

    if len(my_responses) == 1:
        data['my_response'] = my_responses[0]
    elif len(my_responses) > 1:
        data['my_responses'] = my_responses
        data['my_responses_count'] = len(my_responses)

    if project.is_participant(request.user):
        data['revisions'] = [{
            'version_number':
            v.version_number,
            'versioned_id':
            v.versioned_id,
            'author':
            get_public_name(v.instance().author, request),
            'modified':
            v.modified.strftime("%m/%d/%y %I:%M %p")
        } for v in versions]

    if can_edit:
        projectform = ProjectForm(request, instance=project)
        data['form'] = {
            'participants': projectform['participants'].__unicode__(),
            'publish': projectform['publish'].__unicode__()
        }

    return data
Esempio n. 36
0
    def render_one(self, request, project, version_number=None):
        bundle = self.build_bundle(obj=project, request=request)
        dehydrated = self.full_dehydrate(bundle)
        project_ctx = self._meta.serializer.to_simple(dehydrated, None)
        project_ctx["body"] = project.body
        project_ctx["public_url"] = project.public_url()
        project_ctx["current_version"] = version_number
        project_ctx["visibility"] = project.visibility_short()
        project_ctx["type"] = "assignment" if project.is_assignment(request) else "composition"

        rand = "".join([choice(letters) for i in range(5)])

        asset_resource = AssetResource()
        sherd_resource = SherdNoteResource()

        assets = {}
        notes = []
        for note in project.citations():
            notes.append(sherd_resource.render_one(request, note, rand))
            if note.title not in ["Annotation Deleted", "Asset Deleted"]:
                key = "%s_%s" % (rand, note.asset.pk)
                if key not in assets.keys():
                    assets[key] = asset_resource.render_one(request, note.asset)

        data = {
            "project": project_ctx,
            "type": "project",
            "can_edit": self.editable,
            "annotations": notes,
            "assets": assets,
        }

        data["responses"] = []
        for response in project.responses(request):
            if response.can_read(request):
                obj = {
                    "url": response.get_absolute_url(),
                    "title": response.title,
                    "modified": response.modified.strftime(self.date_fmt),
                    "attribution_list": [],
                }

                last = len(response.attribution_list()) - 1
                for idx, author in enumerate(response.attribution_list()):
                    obj["attribution_list"].append({"name": get_public_name(author, request), "last": idx == last})

                data["responses"].append(obj)
        data["response_count"] = len(data["responses"])

        my_responses = []
        for response in project.responses_by(request, request.user):
            obj = {
                "url": response.get_absolute_url(),
                "title": response.title,
                "modified": response.modified.strftime(self.date_fmt),
                "attribution_list": [],
            }

            last = len(response.attribution_list()) - 1
            for idx, author in enumerate(response.attribution_list()):
                obj["attribution_list"].append({"name": get_public_name(author, request), "last": idx == last})

            my_responses.append(obj)

        if len(my_responses) == 1:
            data["my_response"] = my_responses[0]
        elif len(my_responses) > 1:
            data["my_responses"] = my_responses
            data["my_responses_count"] = len(my_responses)

        if project.is_participant(request.user):
            data["revisions"] = [
                {
                    "version_number": v.version_number,
                    "versioned_id": v.versioned_id,
                    "author": get_public_name(v.instance().author, request),
                    "modified": v.modified.strftime("%m/%d/%y %I:%M %p"),
                }
                for v in project.versions.order_by("-change_time")
            ]

        if self.editable:
            projectform = ProjectForm(request, instance=project)
            data["form"] = {
                "participants": projectform["participants"].__unicode__(),
                "publish": projectform["publish"].__unicode__(),
            }

        return data
Esempio n. 37
0
 def author_name(request, annotation, key):
     if not annotation.author_id:
         return None
     return 'author_name', get_public_name(annotation.author, request)
Esempio n. 38
0
def get_records(user, course, request):
    c = course
    today = datetime.date.today()

    editable = (user == request.user)

    #bad language, we should change this to user_of_assets or something
    space_viewer = request.user
    if request.GET.has_key('as') and request.user.is_staff:
        space_viewer = get_object_or_404(User, username=request.GET['as'])

    assignments = []
    responder = None

    if user == 'all':
        archives = list(course.asset_set.archives())
        assets = [
            a for a in Asset.objects.filter(course=c).extra(
                select={
                    'lower_title': 'lower(assetmgr_asset.title)'
                }).select_related().order_by('lower_title')
            if a not in archives
        ]
        user = None

        all_tags = Tag.objects.usage_for_queryset(
            SherdNote.objects.filter(asset__course=course), counts=True)
        all_tags.sort(lambda a, b: cmp(a.name.lower(), b.name.lower()))
        tags = calculate_cloud(all_tags)

        projects = [
            p for p in Project.objects.filter(course=c,
                                              submitted=True).order_by('title')
            if p.visible(request)
        ]

    else:
        assets = annotated_by(Asset.objects.filter(course=c),
                              user,
                              include_archives=c.is_faculty(user))

        tags = calculate_cloud(
            Tag.objects.usage_for_queryset(
                user.sherdnote_set.filter(asset__course=c), counts=True))

        projects = Project.get_user_projects(user, c).order_by('-modified')
        if not editable:
            projects = [p for p in projects if p.visible(request)]

        project_type = ContentType.objects.get_for_model(Project)
        assignments = []
        maybe_assignments = Project.objects.filter(c.faculty_filter)
        for assignment in maybe_assignments:
            if not assignment.visible(request):
                continue
            if assignment in projects:
                continue
            if is_unanswered_assignment(assignment, user, request,
                                        project_type):
                assignments.append(assignment)

        if user.id == space_viewer.id:
            responder = space_viewer.username

    for fil in filter_by:
        filter_value = request.GET.get(fil)
        if filter_value:
            assets = [
                asset for asset in assets
                if filter_by[fil](asset, filter_value, user)
            ]

    active_filters = get_active_filters(request, filter_by)

    if request.is_ajax():
        asset_json = []
        for asset in assets:
            the_json = asset.sherd_json(request)
            gannotation, created = SherdNote.objects.global_annotation(
                asset, user or space_viewer, auto_create=False)
            if gannotation:
                the_json['global_annotation'] = gannotation.sherd_json(
                    request, 'x', ('tags', 'body'))

            the_json['editable'] = editable

            annotations = []
            if request.GET.has_key('annotations'):
                # @todo: refactor this serialization into a common place.
                def author_name(request, annotation, key):
                    if not annotation.author_id:
                        return None
                    return 'author_name', get_public_name(
                        annotation.author, request)

                for ann in asset.sherdnote_set.filter(range1__isnull=False,
                                                      author=user):
                    annotations.append(
                        ann.sherd_json(request, 'x',
                                       ('title', 'author', 'tags', author_name,
                                        'body', 'modified', 'timecode')))
                the_json['annotations'] = annotations

            asset_json.append(the_json)

        project_json = []
        for p in projects:
            the_json = {}
            the_json['id'] = p.id
            the_json['title'] = p.title
            the_json['url'] = p.get_absolute_url()

            participants = p.attribution_list()
            the_json['authors'] = [{
                'name': get_public_name(u, request)
            } for u in participants]
            the_json['modified'] = p.modified.strftime("%m/%d/%y %I:%M %p")
            the_json['status'] = p.status()
            the_json['editable'] = editable

            feedback = p.feedback_discussion()
            if feedback:
                the_json['feedback'] = feedback.id

            collaboration = p.collaboration()
            if collaboration:
                collaboration_parent = collaboration.get_parent()
                if collaboration_parent:
                    the_json['collaboration'] = {}
                    the_json['collaboration'][
                        'title'] = collaboration_parent.title
                    if collaboration_parent.content_object:
                        the_json['collaboration'][
                            'url'] = collaboration_parent.content_object.get_absolute_url(
                            )

            project_json.append(the_json)

        data = {
            'assets':
            asset_json,
            'assignments': [{
                'id':
                a.id,
                'responder':
                responder,
                'url':
                a.get_absolute_url(),
                'title':
                a.title,
                'modified':
                a.modified.strftime("%m/%d/%y %I:%M %p")
            } for a in assignments],
            'projects':
            project_json,
            'tags': [{
                'name': tag.name
            } for tag in tags],
            'active_filters':
            active_filters,
            'space_viewer': {
                'username': space_viewer.username,
                'public_name': get_public_name(space_viewer, request),
                'can_manage': (space_viewer.is_staff and not user)
            },
            'editable':
            editable,
            'owners': [{
                'username': m.username,
                'public_name': get_public_name(m, request)
            } for m in request.course.members],
            'compositions':
            len(projects) > 0 or len(assignments) > 0,
            'is_faculty':
            c.is_faculty(space_viewer),
        }

        if user:
            data['space_owner'] = {
                'username': user.username,
                'public_name': get_public_name(user, request)
            }

        json_stream = simplejson.dumps(data, indent=2)
        return HttpResponse(json_stream, mimetype='application/json')
    else:
        dates = (
            ('today', 'today'),
            ('yesterday', 'yesterday'),
            ('lastweek', 'within the last week'),
        )

        return {
            'assets': assets,
            'assignments': assignments,
            'projects': projects,
            'tags': tags,
            'dates': dates,
            'space_owner': user,
            'space_viewer': space_viewer,
            'editable': editable,
            'active_filters': active_filters,
        }
Esempio n. 39
0
    def test_get_public_name(self):
        r = DummyRequest()
        assert get_public_name(self.student, r) == "student"

        assert get_public_name([self.student, ], r) == "student"
Esempio n. 40
0
def project_json(request, project, can_edit, version_number=None):
    '''
        JSON representation for a project. Includes:
        * basic project information
        * assets
        * annotations
        * responses (if applicable & permissable)
        * revisions (if permissable)
        * a project participant form (if permissable)
    '''
    
    rand = ''.join([choice(letters) for i in range(5)])
    
    versions = project.versions.order_by('-change_time')
    participants = project.attribution_list()
    is_assignment = project.is_assignment(request)
    
    data = { 'project': { 'title': project.title,
                          'body': project.body,
                          'participants': [{ 'name': p.get_full_name(),
                                             'username': p.username,
                                             'public_name': get_public_name(p, request),
                                             'is_viewer': request.user.username == p.username,
                                             'last':  idx == (len(participants) - 1) 
                                            } for idx, p in enumerate(participants)],
                          'id': project.pk,
                          'url': project.get_absolute_url(),
                          'public_url': project.public_url(),
                          'visibility': project.visibility_short(),
                          'username': request.user.username,
                          'type': 'assignment' if is_assignment else 'composition',
                          'current_version': version_number if version_number else None,
                          'create_selection': is_assignment,
                          'is_assignment': is_assignment
                       },
            'assets': dict([('%s_%s' % (rand,ann.asset.pk),
                            ann.asset.sherd_json(request)
                            ) for ann in project.citations()
                           if ann.title and ann.title != "Annotation Deleted" and ann.title != 'Asset Deleted'
                           ]),
            'annotations': [ ann.sherd_json(request, rand, ('title','author')) 
                                for ann in project.citations()
                           ],
            'type': 'project',
            'can_edit': can_edit,
    }
    
    data['responses'] = []
    for r in project.responses(request):
        if r.can_read(request):
            obj = { 'url': r.get_absolute_url(),
                    'title': r.title,
                    'modified': r.modified.strftime("%m/%d/%y %I:%M %p"),
                    'attribution_list': [] }
            
            x = len(r.attribution_list()) - 1
            for idx, author in enumerate(r.attribution_list()):
                obj['attribution_list'].append({ 'name': get_public_name(author, request),
                                                 'last': idx == x }) 
                
            data['responses'].append(obj)
    data['response_count'] = len(data['responses'])
    
    my_responses = []
    for r in project.responses_by(request, request.user):
        obj = { 'url': r.get_absolute_url(),
                'title': r.title,
                'modified': r.modified.strftime("%m/%d/%y %I:%M %p"),
                'attribution_list': [] }
        
        x = len(r.attribution_list()) - 1
        for idx, author in enumerate(r.attribution_list()):
            obj['attribution_list'].append({ 'name': get_public_name(author, request),
                                             'last': idx == x }) 
            
        my_responses.append(obj)
        
    if len(my_responses) == 1:
        data['my_response'] = my_responses[0]
    elif len(my_responses) > 1:
        data['my_responses'] = my_responses
        data['my_responses_count'] = len(my_responses)
    
    if project.is_participant(request.user):
        data['revisions'] = [{ 'version_number': v.version_number,
                               'versioned_id': v.versioned_id,
                               'author': get_public_name(v.instance().author, request),
                               'modified': v.modified.strftime("%m/%d/%y %I:%M %p") }
                              for v in versions ]
                              
    if can_edit:
        projectform = ProjectForm(request, instance=project)
        data['form'] = { 'participants': projectform['participants'].__unicode__(), 'publish': projectform['publish'].__unicode__() }
        
    return data
Esempio n. 41
0
def get_records(user, course, request):
    c = course
    today = datetime.date.today()

    editable = (user==request.user)
    
    #bad language, we should change this to user_of_assets or something
    space_viewer = request.user 
    if request.GET.has_key('as') and request.user.is_staff:
        space_viewer = get_object_or_404(User, username=request.GET['as'])
    
    assignments = []
    responder = None
    
    if user == 'all':
        archives = list(course.asset_set.archives())
        assets = [a for a in Asset.objects.filter(course=c).extra(
            select={'lower_title': 'lower(assetmgr_asset.title)'}
            ).select_related().order_by('lower_title')
              if a not in archives]
        user = None
        
        all_tags = Tag.objects.usage_for_queryset(
            SherdNote.objects.filter(
                asset__course=course),
            counts=True)
        all_tags.sort(lambda a,b:cmp(a.name.lower(),b.name.lower()))
        tags = calculate_cloud(all_tags)
        
        projects = [p for p in Project.objects.filter(course=c,
                                                  submitted=True).order_by('title')
                if p.visible(request)]
        
        
    else:
        assets = annotated_by(Asset.objects.filter(course=c),
                          user,
                          include_archives=c.is_faculty(user)
                          )
        
        tags = calculate_cloud(Tag.objects.usage_for_queryset(
        user.sherdnote_set.filter(
            asset__course=c),
        counts=True))
                
        projects = Project.get_user_projects(user, c).order_by('-modified')
        if not editable:
            projects = [p for p in projects if p.visible(request)]

        project_type = ContentType.objects.get_for_model(Project)
        assignments = []
        maybe_assignments = Project.objects.filter(
            c.faculty_filter)
        for assignment in maybe_assignments:
            if not assignment.visible(request):
                continue
            if assignment in projects:
                continue
            if is_unanswered_assignment(assignment, user, request, project_type):
                assignments.append(assignment)
        
        if user.id == space_viewer.id:
            responder =  space_viewer.username
    
    for fil in filter_by:
        filter_value = request.GET.get(fil)
        if filter_value:
            assets = [asset for asset in assets
                      if filter_by[fil](asset, filter_value, user)]
    
    active_filters = get_active_filters(request, filter_by)
    

    
    if request.is_ajax():
        asset_json = []
        for asset in assets:
            the_json = asset.sherd_json(request)
            gannotation, created = SherdNote.objects.global_annotation(asset, user or space_viewer, auto_create=False)
            if gannotation:
                the_json['global_annotation'] = gannotation.sherd_json(request, 'x', ('tags','body') )
                
            the_json['editable'] = editable
                
            annotations = []
            if request.GET.has_key('annotations'):
                # @todo: refactor this serialization into a common place.
                def author_name(request, annotation, key):
                    if not annotation.author_id:
                        return None
                    return 'author_name',get_public_name(annotation.author, request)
                for ann in asset.sherdnote_set.filter(range1__isnull=False,author=user):
                    annotations.append( ann.sherd_json(request, 'x', ('title','author','tags',author_name,'body','modified', 'timecode') ) )
                the_json['annotations'] = annotations
                
            asset_json.append(the_json)
            
        project_json = []
        for p in projects:
            the_json = {}
            the_json['id'] = p.id
            the_json['title'] = p.title
            the_json['url'] = p.get_absolute_url()
            
            participants = p.attribution_list()
            the_json['authors'] = [ {'name': get_public_name(u, request) } for u in participants]
            the_json['modified'] = p.modified.strftime("%m/%d/%y %I:%M %p")
            the_json['status'] = p.status()
            the_json['editable'] = editable
            
            feedback = p.feedback_discussion()
            if feedback:
                the_json['feedback'] = feedback.id
            
            collaboration = p.collaboration()
            if collaboration:
                collaboration_parent = collaboration.get_parent()
                if collaboration_parent:
                    the_json['collaboration'] = {}
                    the_json['collaboration']['title'] = collaboration_parent.title
                    if collaboration_parent.content_object:
                        the_json['collaboration']['url'] = collaboration_parent.content_object.get_absolute_url()
            
            project_json.append(the_json)
    
        data = {'assets': asset_json,
                'assignments' : [ {'id': a.id, 'responder': responder, 'url': a.get_absolute_url(), 'title': a.title, 'modified': a.modified.strftime("%m/%d/%y %I:%M %p")} for a in assignments],
                'projects' : project_json,
                'tags': [ { 'name': tag.name } for tag in tags ],
                'active_filters': active_filters,
                'space_viewer'  : { 'username': space_viewer.username, 'public_name': get_public_name(space_viewer, request), 'can_manage': (space_viewer.is_staff and not user) },
                'editable' : editable,
                'owners' : [{ 'username': m.username, 'public_name': get_public_name(m, request) } for m in request.course.members],
                'compositions' : len(projects) > 0 or len(assignments) > 0,
                'is_faculty': c.is_faculty(space_viewer),    
               }
        
        if user:
            data['space_owner'] = { 'username': user.username, 'public_name': get_public_name(user, request) }
    
        json_stream = simplejson.dumps(data, indent=2)
        return HttpResponse(json_stream, mimetype='application/json')
    else:
        dates = (('today','today'),
             ('yesterday','yesterday'),
             ('lastweek','within the last week'),)    
            
        
        return {
            'assets'        : assets,
            'assignments'   : assignments,
            'projects'      : projects,
            'tags'          : tags,
            'dates'         : dates,
            'space_owner'   : user,
            'space_viewer'  : space_viewer,
            'editable'      : editable,
            'active_filters': active_filters,
            }
Esempio n. 42
0
def composition_project_json(request, project, can_edit, version_number=None):
    '''
        JSON representation for a project. Includes:
        * basic project information
        * assets
        * annotations
        * responses (if applicable & permissable)
        * revisions (if permissable)
        * a project participant form (if permissable)
    '''

    rand = ''.join([choice(letters) for i in range(5)])

    participants = project.attribution_list()
    is_assignment = project.is_assignment(request)

    course = request.course if request.course \
        else request.collaboration_context.content_object

    asset_resource = AssetSummaryResource()
    sherd_resource = SherdNoteResource()
    citations = project.citations()

    data = {
        'project': {
            'id': project.pk,
            'title': project.title,
            'url': project.get_absolute_url(),
            'due_date': project.get_due_date(),
            'body': project.body,
            'participants': [{
                'name': p.get_full_name(),
                'username': p.username,
                'public_name': get_public_name(p, request),
                'is_viewer': request.user.username == p.username,
                'last': idx == (len(participants) - 1)
            } for idx, p in enumerate(participants)],
            'public_url': project.public_url(),
            'visibility': project.visibility_short(),
            'username': request.user.username,
            'type': 'assignment' if is_assignment else 'composition',
            'description': project.description(),
            'current_version': version_number if version_number else None,
            'create_selection': is_assignment,
            'is_assignment': is_assignment,
            'course_title': course.title
        },
        'type': 'project',
        'can_edit': can_edit,
        'annotations': [sherd_resource.render_one(request, ann, rand)
                        for ann in citations],
    }

    assets = {}
    for ann in citations:
        if ann.title != "Annotation Deleted" and ann.title != 'Asset Deleted':
            key = '%s_%s' % (rand, ann.asset.pk)
            if key not in assets:
                assets[key] = asset_resource.render_one(request, ann.asset)
    data['assets'] = assets

    data['responses'] = []
    for response in project.responses(request):
        if response.can_read(request):
            obj = {'url': response.get_absolute_url(),
                   'title': response.title,
                   'modified': response.modified.strftime("%m/%d/%y %I:%M %p"),
                   'attribution_list': []}

            last = len(response.attribution_list()) - 1
            for idx, author in enumerate(response.attribution_list()):
                obj['attribution_list'].append({
                    'name': get_public_name(author, request),
                    'last': idx == last})

            data['responses'].append(obj)
    data['response_count'] = len(data['responses'])

    my_responses = []
    for response in project.responses_by(request, request.user):
        obj = {'url': response.get_absolute_url(),
               'title': response.title,
               'modified': response.modified.strftime("%m/%d/%y %I:%M %p"),
               'attribution_list': []}

        last = len(response.attribution_list()) - 1
        for idx, author in enumerate(response.attribution_list()):
            obj['attribution_list'].append({'name': get_public_name(author,
                                                                    request),
                                            'last': idx == last})

        my_responses.append(obj)

    if len(my_responses) == 1:
        data['my_response'] = my_responses[0]
    elif len(my_responses) > 1:
        data['my_responses'] = my_responses
        data['my_responses_count'] = len(my_responses)

    if project.is_participant(request.user):
        data['revisions'] = [{
            'version_number': v.version_number,
            'versioned_id': v.versioned_id,
            'author': get_public_name(v.instance().author, request),
            'modified': v.modified.strftime("%m/%d/%y %I:%M %p")}
            for v in project.versions.order_by('-change_time')]

    if can_edit:
        projectform = ProjectForm(request, instance=project)
        data['form'] = {
            'participants': projectform['participants'].__unicode__(),
            'publish': projectform['publish'].__unicode__()
        }

    return data
Esempio n. 43
0
 def author_name(request, annotation, key):
     if not annotation.author_id:
         return None
     return 'author_name',get_public_name(annotation.author, request)
Esempio n. 44
0
 def dehydrate(self, bundle):
     bundle.data['public_name'] = get_public_name(bundle.obj,
                                                  bundle.request)
     return bundle
Esempio n. 45
0
    def test_get_public_name(self):
        r = DummyRequest()
        self.assertEqual(get_public_name(self.student, r), "student")

        self.assertEqual(get_public_name([self.student, ], r), "student")
Esempio n. 46
0
def get_records(request, record_owner, projects, assignments, assets):
    course = request.course
    logged_in_user = request.user

    # Can the record_owner edit the records
    viewing_my_records = (record_owner == logged_in_user)
    viewing_faculty_records = record_owner and course.is_faculty(record_owner)

    # Allow the logged in user to add assets to his composition
    citable = request.GET.has_key('citable') and request.GET.get(
        'citable') == 'true'

    # Is the current user faculty OR staff
    is_faculty = course.is_faculty(logged_in_user)

    # Does the course allow viewing other user selections?
    owner_selections_are_visible = course_details.all_selections_are_visible(course) or \
        viewing_my_records or viewing_faculty_records or is_faculty

    # Filter the assets
    for fil in filter_by:
        filter_value = request.GET.get(fil)
        if filter_value:
            assets = [
                asset for asset in assets
                if filter_by[fil](asset, filter_value, record_owner)
            ]

    active_filters = get_active_filters(request, filter_by)

    # Spew out json for the assets
    asset_json = []
    options = {
        'owner_selections_are_visible':
        request.GET.has_key('annotations') and owner_selections_are_visible,
        'all_selections_are_visible':
        course_details.all_selections_are_visible(course) or is_faculty,
        'can_edit':
        viewing_my_records,
        'citable':
        citable
    }

    for asset in assets:
        asset_json.append(
            homepage_asset_json(request, asset, logged_in_user, record_owner,
                                options))

    # Spew out json for the projects
    project_json = []
    for p in projects:
        project_json.append(
            homepage_project_json(request, p, viewing_my_records))

    # Tags
    tags = []
    if record_owner:
        if owner_selections_are_visible:
            # Tags for selected user
            tags = Tag.objects.usage_for_queryset(
                record_owner.sherdnote_set.filter(asset__course=course),
                counts=True)
    else:
        if owner_selections_are_visible:
            # Tags for the whole class
            tags = Tag.objects.usage_for_queryset(
                SherdNote.objects.filter(asset__course=course), counts=True)
        else:
            # Tags for myself and faculty members
            tags = Tag.objects.usage_for_queryset(
                logged_in_user.sherdnote_set.filter(asset__course=course),
                counts=True)

            for f in course.faculty:
                tags.extend(
                    Tag.objects.usage_for_queryset(
                        f.sherdnote_set.filter(asset__course=course),
                        counts=True))

    tags.sort(lambda a, b: cmp(a.name.lower(), b.name.lower()))

    # Assemble the context
    data = {
        'assets':
        asset_json,
        'assignments': [{
            'id': a.id,
            'url': a.get_absolute_url(),
            'title': a.title,
            'modified': a.modified.strftime("%m/%d/%y %I:%M %p")
        } for a in assignments],
        'projects':
        project_json,
        'tags': [{
            'name': tag.name
        } for tag in tags],
        'active_filters':
        active_filters,
        'space_viewer': {
            'username': logged_in_user.username,
            'public_name': get_public_name(logged_in_user, request),
            'can_manage': (logged_in_user.is_staff and not record_owner)
        },
        'editable':
        viewing_my_records,
        'citable':
        citable,
        'owners': [{
            'username': m.username,
            'public_name': get_public_name(m, request)
        } for m in request.course.members],
        'compositions':
        len(projects) > 0 or len(assignments) > 0,
        'is_faculty':
        is_faculty,
    }

    if record_owner:
        data['space_owner'] = {
            'username': record_owner.username,
            'public_name': get_public_name(record_owner, request)
        }

    json_stream = simplejson.dumps(data, indent=2)
    return HttpResponse(json_stream, mimetype='application/json')