示例#1
0
def my_tags_portlet(context):
    user = context["request"].user
    tags = dict(Tag.objects.filter(user=user).values("slug").annotate(count=Count("slug")).values_list("slug", "count"))
    tags = get_tag_cloud(tags, 3, 0, 1)
    for tag in tags:
        tag["name"] = get_name_from_slug(Tag, tag["slug"])
    return dict(tags=tags)
示例#2
0
def item_tags_portlet(context, item):
    request = context["request"]
    user = request.user
    if user.is_authenticated():
        user_tags = item.tags.filter(user=user).order_by("slug")
        can_add_tags = True
    else:
        user_tags = []
        can_add_tags = False

    item_tags = item.tags.all() 
    if user_tags:
        item_tags = item_tags.exclude(id__in=user_tags.values_list("id", flat=True))

    tags = {}
    for tag in item_tags:
        tags[tag.slug] = tags.get(tag.slug, 0) + 1
    tags = get_tag_cloud(tags, 3, 0, 1)
    for tag in tags:
        tag["name"] = get_name_from_slug(Tag, tag["slug"])

    content_type = ContentType.objects.get_for_model(item)

    return dict(item=item,
                tags=tags,
                user_tags=user_tags,
                app_label=content_type.app_label,
                model=content_type.model,
                can_add_tags=can_add_tags)
示例#3
0
def microsite(request, microsite):

    microsite = get_object_or_404(Microsite, slug=microsite)

    page_title = u"%s Home" % microsite.name
    breadcrumbs = [{"url": reverse("materials:microsite", kwargs=dict(microsite=microsite.slug)), "title": page_title}]

    query = SearchQuerySet().narrow("is_displayed:true")
    query = query.narrow("microsites:%i" % microsite.id)
    query = query.order_by("-rating")
    query = query.facet("indexed_topics").facet("keywords").facet("grade_levels").facet("course_material_types")

    items = []
    results = query[0:8]
    for result in results:
        items.append(populate_item_from_search_result(result))

    facets = query.facet_counts()["fields"]

    topics = []
    topic_counts = dict(facets["indexed_topics"])
    for topic, tree_info in tree_item_iterator(microsite.topics.all()):
        topic.count = topic_counts.get(str(topic.id), 0)
        topics.append((topic, tree_info))

    grade_levels = []
    grade_level_counts = dict(facets["grade_levels"])
    for level in GradeLevel.objects.all():
        level.count = grade_level_counts.get(str(level.id), 0)
        grade_levels.append(level)

    course_material_types = []
    course_material_type_counts = dict(facets["course_material_types"])
    for material_type in CourseMaterialType.objects.all():
        material_type.count = course_material_type_counts.get(str(material_type.id), 0)
        course_material_types.append(material_type)

    keywords = query.count() and facets.get("keywords", []) or []
    if len(keywords) > MAX_TOP_KEYWORDS:
        keywords = keywords[:MAX_TOP_KEYWORDS]
    keywords = get_tag_cloud(dict(keywords), 3, 0, 0)
    for keyword in keywords:
        name = get_name_from_slug(Keyword, keyword["slug"]) or \
               get_name_from_slug(Tag, keyword["slug"]) or \
               keyword["slug"]
        keyword["name"] = name

    featured_k12 = SearchQuerySet().filter(workflow_state=PUBLISHED_STATE, featured=True, grade_levels__in=(1, 2), microsites=microsite.id).order_by("-featured_on").load_all()[:3]
    featured_k12 = [r.object for r in featured_k12 if r]

    featured_highered = SearchQuerySet().filter(workflow_state=PUBLISHED_STATE, featured=True, grade_levels=3, microsites=microsite.id).order_by("-featured_on").load_all()[:3]
    featured_highered = [r.object for r in featured_highered if r]

    slides = Slide.objects.filter(microsite=microsite)

    resource_number = SearchQuerySet().filter(workflow_state=PUBLISHED_STATE, microsites=microsite.id).count()

    return direct_to_template(request, "materials/microsites/%s.html" % microsite.slug, locals())
示例#4
0
def frontpage(request):

    keywords = get_facets_for_field("keywords")
    if len(keywords) > MAX_TAGS:
        keywords = keywords[:MAX_TAGS]
    tagcloud = get_tag_cloud(dict(keywords), max_font=4, min_font=0,
                             average_font=1)

    for keyword in tagcloud:
        name = get_name_from_slug(Keyword, keyword["slug"]) or \
               get_name_from_slug(Tag, keyword["slug"]) or \
               keyword["slug"]
        keyword["name"] = name

    general_subjects_facets = dict(get_facets_for_field("general_subjects"))
    general_subjects = list(GeneralSubject.objects.values("id", "slug", "name"))
    for s in general_subjects:
        s["count"] = general_subjects_facets.get(unicode(s["id"]), 0)


    grade_levels_facets = dict(get_facets_for_field("grade_levels"))
    grade_levels = list(GradeLevel.objects.values("id", "slug", "name"))
    for s in grade_levels:
        s["count"] = grade_levels_facets.get(unicode(s["id"]), 0)

    slides = Slide.objects.filter(microsite=None)

    microsites = Microsite.objects.all()
    microsites_ids = tuple(microsites.values_list("id", flat=True))

    featured_k12 = SearchQuerySet().filter(featured=True, grade_levels__in=(1, 2)).exclude(microsites__in=microsites_ids).order_by("-featured_on").load_all()[:3]
    featured_k12 = [r.object for r in featured_k12 if r]

    featured_highered = SearchQuerySet().filter(featured=True, grade_levels=3).exclude(microsites__in=microsites_ids).order_by("-featured_on").load_all()[:3]
    featured_highered = [r.object for r in featured_highered if r]

    resource_number = SearchQuerySet().filter(workflow_state=PUBLISHED_STATE).count()

    return direct_to_template(request, "frontpage.html",
                              dict(tagcloud=tagcloud,
                                   general_subjects=general_subjects,
                                   grade_levels=grade_levels,
                                   microsites=microsites,
                                   tweets=get_tweets(),
                                   slides=slides,
                                   featured_k12=featured_k12,
                                   featured_highered=featured_highered,
                                   resource_number=resource_number,
                               ))
示例#5
0
def green_browse(request):

    microsite = get_object_or_404(Microsite, slug="green")

    query = SearchQuerySet().narrow("is_displayed:true")
    query = query.narrow("microsites:%i" % microsite.id)
    query = query.facet("indexed_topics").facet("keywords").facet("grade_levels").facet("course_material_types")

    facets = query.facet_counts()["fields"]

    topics = []
    topic_counts = dict(facets["indexed_topics"])
    for topic, tree_info in tree_item_iterator(microsite.topics.all()):
        topic.count = topic_counts.get(str(topic.id), 0)
        topics.append((topic, tree_info))

    grade_levels = []
    grade_level_counts = dict(facets["grade_levels"])
    for level in GradeLevel.objects.all():
        level.count = grade_level_counts.get(str(level.id), 0)
        grade_levels.append(level)

    course_material_types = []
    course_material_type_counts = dict(facets["course_material_types"])
    for material_type in CourseMaterialType.objects.all():
        material_type.count = course_material_type_counts.get(str(material_type.id), 0)
        course_material_types.append(material_type)

    keywords = query.count() and facets.get("keywords", []) or []
    if len(keywords) > MAX_TOP_KEYWORDS:
        keywords = keywords[:MAX_TOP_KEYWORDS]
    keywords = get_tag_cloud(dict(keywords), 3, 0, 0)
    for keyword in keywords:
        name = get_name_from_slug(Keyword, keyword["slug"]) or \
               get_name_from_slug(Tag, keyword["slug"]) or \
               keyword["slug"]
        keyword["name"] = name

    query = SearchQuerySet().narrow("is_displayed:true")
    query = query.narrow("microsites:%i" % microsite.id)
    query = query.order_by("-published_on").load_all()
    recently_added = [r.object for r in query[:7]]

    return direct_to_template(request, "materials/microsites/green-browse.html", locals())
示例#6
0
def index(
    request,
    general_subjects=None,
    grade_levels=None,
    course_material_types=None,
    library_material_types=None,
    collection=None,
    keywords=None,
    license=None,
    course_or_module=None,
    community_types=None,
    community_topics=None,
    microsite=None,
    model=None,
    search=False,
    tags=None,
    subjects=None,
    format=None,
    topics=None,
    alignment=None,
    facet_fields=None,
):

    if not facet_fields:
        facet_fields = [
            "general_subjects",
            "grade_levels",
            "keywords",
            "course_material_types",
            "media_formats",
            "cou_bucket",
            "indexed_topics",
        ]
    if model:
        index_namespace = model.namespace
    else:
        index_namespace = None

    if tags or subjects:
        # Tags and subjects are old path filters which are combined to
        # keywords filter now.

        # Redirect to keyword index.
        keywords = tags or subjects
        if index_namespace:
            url = reverse("materials:%s:keyword_index" % index_namespace, kwargs=dict(keywords=keywords))
        else:
            url = reverse("materials:keyword_index", kwargs=dict(keywords=keywords))
        return HttpResponsePermanentRedirect(url)

    if keywords:
        slugified_keywords = slugify(keywords)
        if not slugified_keywords:
            raise Http404()
        if slugified_keywords != keywords:
            # Keywords should be slugified.
            # Redirect to keyword index with slugified keyword.
            if index_namespace:
                url = reverse("materials:%s:keyword_index" % index_namespace, kwargs=dict(keywords=slugified_keywords))
            else:
                url = reverse("materials:keyword_index", kwargs=dict(keywords=slugified_keywords))
            return HttpResponsePermanentRedirect(url)

    query_string_params = {}
    filter_values = {}
    page_title = u"Browse"
    page_subtitle = u""
    breadcrumbs = [{"url": reverse("materials:browse"), "title": u"OER Materials"}]

    if not format:
        format = "html"
        if request.REQUEST.get("feed", None) == "yes":
            format = "rss"
        elif request.REQUEST.get("csv", None) == "yes":
            if not request.user.is_authenticated() or not request.user.is_staff:
                raise Http404()
            format = "csv"

    query = SearchQuerySet().narrow("is_displayed:true")

    if model:
        query = query.models(model)

    path_filter = None

    hidden_filters = {}

    for filter_name in PATH_FILTERS:
        value = locals()[filter_name]
        if value is not None:
            filter = FILTERS[filter_name]
            query = filter.update_query(query, value)
            path_filter = filter_name
            if page_subtitle:
                page_subtitle = u"%s → %s" % (page_subtitle, filter.page_subtitle(value))
            else:
                page_subtitle = filter.page_subtitle(value)
            filter_values[filter_name] = value

    visible_filters = [
        "search",
        "general_subjects",
        "grade_levels",
        "course_material_types",
        "media_formats",
        "cou_bucket",
    ]

    if microsite:
        microsite = Microsite.objects.get(slug=microsite)
        visible_filters.append("topics")

    search_query = u""

    for filter_name, filter in FILTERS.items():
        if filter_name == path_filter:
            continue
        value = filter.extract_value(request)
        if value is not None:
            query = filter.update_query(query, value)
            query_string_params = filter.update_query_string_params(query_string_params, value)
            filter_values[filter_name] = value
            if filter_name not in visible_filters:
                hidden_filters[filter.request_name] = value
            if filter_name == "search":
                search_query = value

    if search:
        if not search_query:
            if filter_values:
                return HttpResponsePermanentRedirect(
                    reverse("materials:index") + serialize_query_string_params(query_string_params)
                )
            else:
                messages.warning(request, u"You should specify the search term")
                return HttpResponsePermanentRedirect(reverse("materials:advanced_search"))

        page_title = u"Search Results"
        page_subtitle = search_query
        breadcrumbs = [{"url": reverse("materials:search"), "title": page_title}]

    elif model == CommunityItem:
        breadcrumbs = [{"url": reverse("materials:community"), "title": u"OER Community"}]

    if microsite:
        breadcrumbs = [
            {
                "url": reverse("materials:microsite", kwargs=dict(microsite=microsite.slug)),
                "title": u"%s Home" % microsite.name,
            }
        ]

    if not page_subtitle and model:
        page_subtitle = u"Content Type: %s" % model._meta.verbose_name_plural
    elif not page_subtitle and filter_values:
        filter_name = filter_values.keys()[0]
        filter = FILTERS[filter_name]
        page_subtitle = filter.page_subtitle(filter_values[filter_name])

    index_params = IndexParams(request, format, search_query)
    query_string_params = index_params.update_query_string_params(query_string_params)

    index_url = request.path + serialize_query_string_params(query_string_params, ignore_params=["batch_start"])
    if page_subtitle:
        index_title = u"%s: %s" % (page_title, page_subtitle)
    else:
        index_title = page_title

    feed_url = request.path + serialize_query_string_params(
        dict(query_string_params.items() + [("feed", "yes")]), ignore_params=["batch_start"]
    )
    csv_url = request.path + serialize_query_string_params(
        dict(query_string_params.items() + [("csv", "yes")]), ignore_params=["batch_start"]
    )

    batch_end = index_params.batch_start + index_params.batch_size

    if len(filter_values) == 1 and "featured" in filter_values:
        query = query.order_by("-featured_on")
    elif len(filter_values) == 1 and "evaluated_rubrics" in filter_values:
        query = query.order_by("-evaluation_score_rubric_%i" % filter_values["evaluated_rubrics"][0])
    elif index_params.query_order_by is not None:
        query = query.order_by(index_params.query_order_by)

    if index_params.sort_by == "visits" and not filter_values:
        query = query.narrow("visits:[1 TO *]")

    items = []

    if format == "html":

        for facet_field in facet_fields:
            query = query.facet(facet_field)

        total_items = len(query)

        if total_items and index_params.batch_start >= total_items:
            return HttpResponsePermanentRedirect(index_url)

        results = query[index_params.batch_start : batch_end]
        for result in results:
            if result is None:
                continue
            items.append(populate_item_from_search_result(result))

        pagination = Pagination(
            request.path, query_string_params, index_params.batch_start, index_params.batch_size, total_items
        )

        facets = query.facet_counts().get("fields", {})

        index_filters = build_index_filters(visible_filters, facets, filter_values, path_filter, microsite)

        all_keywords = query.count() and facets.get("keywords", []) or []
        if len(all_keywords) > MAX_TOP_KEYWORDS:
            top_keywords = get_tag_cloud(dict(all_keywords[:MAX_TOP_KEYWORDS]), 3, 0, 0)
            all_keywords = get_tag_cloud(dict(all_keywords), 3, 0, 0)
        else:
            top_keywords = get_tag_cloud(dict(all_keywords), 3, 0, 0)
            all_keywords = []

        for keyword in top_keywords:
            name = (
                get_name_from_slug(Keyword, keyword["slug"])
                or get_name_from_slug(Tag, keyword["slug"])
                or keyword["slug"]
            )
            keyword["name"] = name
        for keyword in all_keywords:
            name = (
                get_name_from_slug(Keyword, keyword["slug"])
                or get_name_from_slug(Tag, keyword["slug"])
                or keyword["slug"]
            )
            keyword["name"] = name

        if request.is_ajax():
            output = render_to_string("materials/include/index-items.html", RequestContext(request, locals()))
            data = dict(
                items=output,
                first_item_number=pagination.first_item_number,
                last_item_number=pagination.last_item_number,
                total_items=pagination.total_items,
                page_title=unicode(page_title),
                page_subtitle=page_subtitle and unicode(page_subtitle or u""),
            )
            return JsonResponse(data)
        return direct_to_template(request, "materials/index.html", locals())

    elif format == "rss":
        results = query[0:20]
        for result in results:
            if result is None:
                continue
            item = result.get_stored_fields()
            if item.get("general_subjects"):
                item["general_subjects"] = [get_name_from_id(GeneralSubject, id) for id in item["general_subjects"]]

            namespace = getattr(result.model, "namespace", None)
            if namespace:
                item["get_absolute_url"] = reverse("materials:%s:view_item" % namespace, kwargs=dict(slug=item["slug"]))
            else:
                item["get_absolute_url"] = result.object.get_absolute_url()

            item["model_verbose_name"] = result.model._meta.verbose_name_plural

            items.append(item)

        return direct_to_template(request, "materials/index-rss.xml", locals(), "text/xml")

    elif format == "json":
        results = query[index_params.batch_start : batch_end]

        for result in results:
            if result is None:
                continue
            data = result.get_stored_fields()
            item = {
                "id": result.id,
                "title": data["title"],
                "abstract": data["abstract"],
                "url": data["url"],
                "keywords": data["keywords_names"],
                "subject": [get_slug_from_id(GeneralSubject, id) for id in (data["general_subjects"] or [])],
                "grade_level": [get_slug_from_id(GradeLevel, id) for id in (data["grade_levels"] or [])],
                "collection": data["collection"] and get_name_from_id(Collection, data["collection"]) or None,
            }
            items.append(item)

        return JsonResponse(items)

    elif format == "xml":
        query = query.load_all()
        results = query[index_params.batch_start : batch_end]

        for result in results:
            if result is None:
                continue
            object = result.object
            data = result.get_stored_fields()
            item = {"url": data["url"], "title": data["title"]}
            if data.get("authors"):
                item["author"] = data["authors"][0]
            if data.get("institution"):
                item["institution"] = get_name_from_id(Institution, data["institution"])
            item["abstract"] = data["abstract"]

            license = object.license
            item["copyright_holder"] = license.copyright_holder
            item["license_url"] = license.url
            item["license_name"] = license.name
            item["license_description"] = license.description
            item["license_type"] = license.type
            item["cou_bucket"] = license.bucket

            if data["rating"]:
                item["rating"] = "%.1f" % data["rating"]

            item["fields"] = []
            grade_levels = data.get("grade_levels")
            if grade_levels:
                item["fields"].append(
                    dict(
                        title=u"Grade Level",
                        param=FILTERS["grade_levels"].request_name,
                        value=u",".join([get_slug_from_id(GradeLevel, id) for id in grade_levels]),
                        content=u",".join([get_name_from_id(GradeLevel, id) for id in grade_levels]),
                    )
                )
            general_subjects = data.get("general_subjects")
            if general_subjects:
                item["fields"].append(
                    dict(
                        title=u"Subject",
                        param=FILTERS["general_subjects"].request_name,
                        value=u",".join([get_slug_from_id(GeneralSubject, id) for id in general_subjects]),
                        content=u",".join([get_name_from_id(GeneralSubject, id) for id in general_subjects]),
                    )
                )
            collection = data.get("collection")
            if collection:
                item["fields"].append(
                    dict(
                        title=u"Collection",
                        param=FILTERS["collection"].request_name,
                        value=get_slug_from_id(Collection, collection),
                        content=get_name_from_id(Collection, collection),
                    )
                )
            geographic_relevance = data.get("geographic_relevance")
            if geographic_relevance:
                item["fields"].append(
                    dict(
                        title=u"Geographic Regional Relevance",
                        param=FILTERS["geographic_relevance"].request_name,
                        value=u",".join([get_slug_from_id(GeographicRelevance, id) for id in geographic_relevance]),
                        content=u",".join([get_name_from_id(GeographicRelevance, id) for id in geographic_relevance]),
                    )
                )

            keywords = object.keywords.values("slug", "name")
            if keywords:
                item["fields"].append(
                    dict(
                        title=u"Keywords",
                        param=FILTERS["keywords"].request_name,
                        value=u",".join([k["slug"] for k in keywords]),
                        content=u",".join([k["name"] for k in keywords]),
                    )
                )

            tags = object.tags.values("slug", "name").order_by("slug").distinct()
            if tags:
                item["fields"].append(
                    dict(
                        title=u"Tags",
                        param=FILTERS["keywords"].request_name,
                        value=u",".join([k["slug"] for k in tags]),
                        content=u",".join([k["name"] for k in tags]),
                    )
                )

            items.append(item)

        return direct_to_template(request, "materials/index-xml.xml", locals(), "text/xml")

    elif format == "csv":
        return csv_export(query, index_title)