Produits Entr'ouvert » Combo

    def is_enabled(cls):

        return settings.BOOKING_CALENDAR_CELL_ENABLED and is_chrono_enabled() and is_wcs_enabled()

        return self.agenda_reference and self.formdef_reference \

    def get_cell_extra_context(self, context):

        if context.get('placeholder_search_mode'):

        dashboard = DashboardCell.objects.all()[0]

        cell = CellBase.get_cell(kwargs['cell_reference'])

            raise PermissionDenied()

            raise PermissionDenied()

        cell.pk = None

        cell.page = dashboard.page

                fields=self.get_form_fields(),

                widgets=self.get_form_widgets())

            return False

    @classmethod

    def is_enabled(cls):

            cell = Map.objects.get(pk=kwargs['cell_id'])

        except Map.DoesNotExist:

            raise Http404()

            geojson = cell.get_geojson(request)

            content_type = 'application/json'

            return HttpResponse(json.dumps(geojson), content_type=content_type)

            context['form'] = form

        return super(NewslettersCell, self).render(context)

            return False

    class Meta:

        verbose_name = _('User Notifications')

            return False

    def get_cell_extra_context(self, context):

        extra_context = super(NotificationsCell, self).get_cell_extra_context(context)

        # assemble external links data

        links = {}

        for page in Page.objects.filter(sub_slug=''):

                continue

            for cell in page.get_cells():

                    continue

                for link_data in cell.get_external_links_data():

                    if not link_data['url'] in links:

    class Meta:

        verbose_name = _('Search')

        if not self.search_services:

            return False

    def get_default_form_class(self):

        from .forms import SearchCellForm

    @classmethod

    def ajax_results_view(cls, request, cell_pk, service_slug):

        cell = cls.objects.get(pk=cell_pk)

            raise PermissionDenied

        query = request.GET.get('q')

    def is_enabled(cls):

        return settings.USERSEARCH_CELL_ENABLED

    def modify_global_context(self, context, request):

        if 'selected_user_id' in request.GET:

def ajax_usersearch(request):

    # allow access if the user can see at least one UserSearch cell

    for cell in UserSearchCell.objects.all():

            break

    else:

        raise PermissionDenied

    class Meta:

        abstract = True

            return False

@register_cell_class

        tmpl.render(context, request)

        return placeholders

        pages = Page.get_as_reordered_flat_hierarchy(Page.objects.all())

        this_page = [x for x in pages if x.id == self.id][0]

        pages = pages[pages.index(this_page)+1:]

        for page in pages:

                return page

        return None

        pages = Page.get_as_reordered_flat_hierarchy(Page.objects.all())

        pages.reverse()

        this_page = [x for x in pages if x.id == self.id][0]

        pages = pages[pages.index(this_page)+1:]

        for page in pages:

                return page

        return None

            return ''

        if self.user_dependant:

            return ''

            return ''

            return ''

        request = RequestFactory().get(self.page.get_online_url())

        request.user = None  # compat

    class Meta:

        verbose_name = _('RSS/Atom Feed')

    def get_cell_extra_context(self, context):

        extra_context = super(FeedCell, self).get_cell_extra_context(context)

    def get_additional_label(self):

        return self.title

    def validate_schema(self, value):

        if not isinstance(value, list):

    class Meta:

        abstract = True

    def get_cell_parameters_context(self):

        return {}

        return obj.get_online_url()

    def prepare(self, obj):

            raise SkipDocument()

        return super(PageIndex, self).prepare(obj)

        idp = settings.KNOWN_SERVICES.get('authentic').values()[0]

        return '{%% load combo %%}%sapi/users/{{ concerned_user|name_id }}/' % idp.get('url')

            return False

    def get_cell_extra_context(self, context):

        extra_context = super(ProfileCell, self).get_cell_extra_context(context)

                if not element.public:

                    # mark the menu cell for asynchronous rendering.

                    raise NothingInCacheException()

                continue

        menuitem = {'page': element}

        menuitem['selected'] = bool(element == page_of_level)

    context['cells'] = [x for x in page_cells if

            x.placeholder == placeholder_name and

            (context.get('render_skeleton') or x.is_relevant(context) and

    if context.get('render_skeleton') and not context['cells']:

        context['skeleton'] = skeleton_text(context, placeholder_name)

    else:

        if not (request.user and request.user.is_staff):

            raise PermissionDenied()

        raise PermissionDenied()

    try:

        cell = CellBase.get_cell(cell_reference, page_id=page_pk)

    except ObjectDoesNotExist:

        raise Http404()

        raise PermissionDenied()

    exception = None

        other_cells = []

        for klass in CellBase.get_cell_classes(lambda x: bool(x.modify_global_context)):

            other_cells.extend(klass.objects.filter(page_id=cell.page_id))

        other_cells.sort(key=lambda x: x.order)

        for other_cell in other_cells:

            if other_cell.get_reference() != cell.get_reference():

def publish_page(request, page, status=200, template_name=None):

    pages = page.get_parents_and_self()

        if not request.user.is_authenticated():

            from django.contrib.auth.views import redirect_to_login

            return redirect_to_login(request.build_absolute_uri())

    cells = CellBase.get_cells(page=page)

    extend_with_parent_cells(cells, hierarchy=pages)

    # mark duplicated slugs to avoid using them in HTML id attributes.

    cell_by_slugs = {}

def api_search(request):

    for cell in SearchCell.get_cells_by_search_service('_text'):

            continue

        break

    else:

    context['synchronous'] = True # to get fresh content

    context['request'].user = None

    context['request'].user = john_doe

    assert cell.get_badge(context) is None

    notification1 = Notification.notify(john_doe, 'notibar')

    user1.groups = [group]

    user2 = User(username='bar')

    user2.save()

    page.groups = [group]

    assert not page.is_visible()

def test_import_export_pages():

    page = Page(title=u'foo', slug='foo', order=0, description="Foo's page")

    user1 = User(username='foo')

    user1.save()

    page3.public = False

    page3.save()