Produits Entr'ouvert » Combo

        return settings.COMBO_DASHBOARD_ENABLED

    def is_relevant(self, context):

            return False

        return True

class DashboardAddTileView(View):

    def get(self, request, *args, **kwargs):

            raise PermissionDenied()

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

        if context.get('placeholder_search_mode'):

            return {}

        user = self.get_concerned_user(context)

            return {}

        response = get_family(user=user,

                                   raise_if_not_cached=not(context.get('synchronous')))

                widgets=self.get_form_widgets())

    def is_visible(self, user=None):

            return False

        return super(RecentDocumentsCell, self).is_visible(user)

        return Regie.objects.count() > 0

    def is_relevant(self, context):

            return False

        return BasketItem.get_items_to_be_paid(context['request'].user).count() > 0

    def get_badge(self, context):

            return

        items = BasketItem.get_items_to_be_paid(context['request'].user)

        if not items:

        return Regie.objects.count() > 0

    def is_relevant(self, context):

            return False

        transactions = Transaction.objects.filter(

                user=context['request'].user,

        return Regie.objects.count() > 0

    def is_relevant(self, context):

            return False

        return BasketItem.get_items_to_be_paid(context['request'].user).count() > 0

    def render(self, context):

            return ''

        try:

            context['basket_url'] = LingoBasketCell.objects.all()[0].page.get_online_url()

        return Regie.objects.exclude(webservice_url='').count() > 0

    def is_relevant(self, context):

    def get_default_form_class(self):

        fields = ['title', 'text']

            if item.regie != regie:

                messages.error(request, _(u'Invalid grouping for basket items.'))

                return HttpResponseRedirect(next_url)

        transaction = Transaction()

        if user:

            transaction.user = user

    def post(self, request, *args, **kwargs):

        regie_id = request.POST.get('regie')

        next_url = request.POST.get('next_url') or '/'

        remote_items = []

        items = []

        if regie_id and Regie.objects.get(pk=regie_id).is_remote():

class BasketItemPayView(PayMixin, View):

    def get(self, request, *args, **kwargs):

        next_url = request.GET.get('next_url') or '/'

            return HttpResponseForbidden(_('No item payment allowed for anonymous users.'))

        item = BasketItem.objects.get(pk=kwargs['item_id'])

                return HttpResponseRedirect(redirect_url)

        # return to basket page if there are still items to pay

            remaining_basket_items = BasketItem.get_items_to_be_paid(

                user=self.request.user).count()

            if remaining_basket_items:

        return context

    def get_queryset(self):

        return BasketItem.get_items_to_be_paid(user=user)

    def post(self, request, *args, **kwargs):

            messages.error(request, _('An error occured when removing the item. '

                                      '(no authenticated user)'))

            return HttpResponseRedirect(get_basket_url())

    def render(self, context):

        user = context.get('user')

            form = NewslettersManageForm(instance=self, request=context['request'])

            context['form'] = form

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

    def is_visible(self, user=None):

            return False

        return super(NewslettersCell, self).is_visible(user)

        verbose_name = _('User Notifications')

    def is_visible(self, user=None):

            return False

        return super(NotificationsCell, self).is_visible(user)

    def get_cell_extra_context(self, context):

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

        user = getattr(context.get('request'), 'user', None)

            qs = Notification.objects.visible(user)

            extra_context['notifications'] = qs

            extra_context['new_notifications'] = qs.new()

    def get_badge(self, context):

        user = getattr(context.get('request'), 'user', None)

            return

        new_count = Notification.objects.visible(user).new().count()

        if not new_count:

@csrf_exempt

def subscribe_push(request, *args, **kwargs):

        return HttpResponseForbidden()

    if request.method != 'POST':

        return HttpResponseForbidden()

        abstract = True

    def is_visible(self, user=None):

            return False

        return super(WcsUserDataBaseCell, self).is_visible(user)

def element_is_visible(element, user=None):

    if element.public:

        if getattr(element, 'restricted_to_unlogged', None) is True:

        return True

        return False

    if user.is_superuser:

        return True

    @classmethod

    def take(cls, page, request=None, comment=None, deletion=False):

        snapshot = cls(page=page, comment=comment)

            snapshot.user = request.user

        if not deletion:

            snapshot.serialization = page.get_serialized_page()

    def get_form(self, request):

        from .forms import ParametersForm

            groups = set(request.user.groups.values_list('name', flat=True))

        else:

            groups = set()

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

    def is_visible(self, user=None):

            return False

        return super(ProfileCell, self).is_visible(user)

    def get_name_id(self):

        return self.name_id

    def is_authenticated(self):

        return CallableTrue

    def is_anonymous(self):

        return CallableFalse

@register.filter(name='has_role')

def has_role(user, groupname):

        return False

    return user.groups.filter(name=groupname).exists()

@register.filter

def name_id(user):

        user_name_id = user.get_name_id()

        if user_name_id:

            return user_name_id

        parts = ['index']

    if parts == ['index'] and settings.COMBO_INITIAL_LOGIN_PAGE_PATH and (

        profile, created = Profile.objects.get_or_create(user=request.user)

        if not profile.initial_login_view_timestamp:

            # first connection of user, record that and redirect to welcome URL

            return HttpResponseRedirect(settings.COMBO_INITIAL_LOGIN_PAGE_PATH)

    if parts == ['index'] and settings.COMBO_WELCOME_PAGE_PATH and (

        if not request.session.setdefault('visited', False):

            # first visit, the user is not logged in.

            request.session['visited'] = True

    pages = page.get_parents_and_self()

    if not page.is_visible(request.user):

            from django.contrib.auth.views import redirect_to_login

            return redirect_to_login(request.build_absolute_uri())

        raise PermissionDenied()

    def check_manager(user):

        if user and user.is_staff:

            return True

            raise PermissionDenied()

        # As the last resort, show the login form

        return False

        if remote_service:

            if isinstance(user, dict):

                query_params = user.copy()

                if without_user:

                    query_params = {}

                else:

        template_vars['user_email'] = ''

        template_vars['user_nameid'] = ''

        user = getattr(context.get('request'), 'user', None)

            template_vars['user_email'] = quote(user.email)

            user_nameid = user.get_name_id()

            if user_nameid:

class MockUser(object):

    email = 'foo@example.net'

    def get_name_id(self):

        return 'r2d2'

class MockUser(object):

    email = 'foo@example.net'

    def get_name_id(self):

        if self.samlized:

class MockUser(object):

    email = 'foo=3@example.net'

    def __init__(self, samlized=True):

        self.samlized = samlized

class MockUser(object):

    email = 'foo@example.net'

    def get_name_id(self):

        return None

class MockUserWithNameId(object):

    email = 'foo@example.net'

    def get_name_id(self):

        return 'xyz'