Exemple #1
0
def product_add(request, bill_id, product_id):
    """ Add a product to a bill. If this product contains others products,
    we have to add them too.

    :param request: HttpRequest request
    :param bill_id: Facture
    :param product_id: Produit
    """
    bill = get_object_or_404(Facture, pk=bill_id)
    if not set_edition_status(request, bill):
        LOG.debug("[F%s] bill is already in edition mode" % bill_id)
        return bill_view(request, bill.id)
    product = get_object_or_404(Produit, pk=product_id)

    # how many products to add
    count = int(request.session.get('count', 1))
    LOG.debug("[F%s] get %d X %s" % (bill_id, count, product))
    if count > 1:
        request.session['product_to_add'] = product_id
        request.session['product_count'] = count
        request.session['count'] = 1

    sold = ProduitVendu(produit=product)
    sold.save()
    LOG.debug("[F%s] ProduitVendu(%s) created" % (bill_id, product))
    bill.add_product(sold)
    request.session["products_modified"] = bill_id
    return sold_working(request, bill_id, sold.id)
Exemple #2
0
def AgendaYear(request, member_pk=None, year=None):
    """ Main listing, years and months; three years per page."""
    # prev / next years
    member = None
    if member_pk:
        member = get_object_or_404(C4CUser, pk=member_pk)
    else:
        member = get_object_or_404(C4CUser, user=request.user)

    if member != request.user.c4cuser and not member.network.filter(pk=request.user.pk).exists():
        return HttpResponseNotFound('<h1>Page not found</h1>')

    if year:
        year = int(year)
    else:
        year = time.localtime()[0]

    # create a list of months for each year, indicating ones that contain entries and current
    mlst = _get_monthes_for_year(member, year)

    has_entries = False
    for month in mlst:
        if len(month["entries"]) != 0:
            has_entries = True

    context = {'months': mlst, 'member': member, 'year': year, 'has_entries': has_entries}

    return render(request, "agenda.html", context)
Exemple #3
0
def edit_post(request, post_id):
    if request.method == 'POST':
        add_post_form = EditPostForm(request.POST)
        post_inst = get_object_or_404(Posts, id=post_id)
        # user_inst = UserProfile.objects.get(user_id=request.user.id)
        if add_post_form.is_valid():
            # form_instance = add_post_form.save(commit=False)
            post_inst.lift_type = add_post_form.cleaned_data['lift_type']
            post_inst.location = add_post_form.cleaned_data['location']
            post_inst.leaving_date = add_post_form.cleaned_data['leaving_date']
            post_inst.leaving_time = add_post_form.cleaned_data['leaving_time']
            post_inst.return_date = add_post_form.cleaned_data['return_date']
            post_inst.fulfilled = add_post_form.cleaned_data['fulfilled']
            post_inst.spaces = add_post_form.cleaned_data['spaces']
            post_inst.event = add_post_form.cleaned_data['event']
            post_inst.save()

            return redirect(post_inst)

    else:
        post_inst = get_object_or_404(Posts, pk=post_id)
        # This loads a form with an instance of the post we get from the id passed in the url
        add_post_form = EditPostForm(instance=post_inst)

    event_inst = get_object_or_404(Events, pk=post_inst.event_id)
    # print(event_inst.end_date)
    # If post is for event in the future all the events show up in the event drop down
    if event_inst.end_date > datetime.date.today():
        add_post_form.fields['event'].queryset = Events.objects.future_events()

    context = {
        'post_form': add_post_form,
        'page_title': 'Edit post',
    }
    return render(request, 'posts/edit_post.html', context)
Exemple #4
0
def edit_eptitude_for_book_card(
    request, card_id, eptitude_id, book_id, eptitude_form=EptitudeForm, template_name="card/edit_eptitude.html"
):

    card = get_object_or_404(Card, pk=card_id)
    get_object_or_404(Book, pk=book_id)
    redirect_to = "/cards/edit_card_for_book/%s/%s" % (card_id, book_id)

    eptitude = get_object_or_404(CardEptitude, pk=eptitude_id)

    if request.method == "POST":
        form = eptitude_form(card, request.POST)
        if form.is_valid():
            editEptitudeByRequest(request, eptitude)
            return HttpResponseRedirect(redirect_to)

    else:

        data = getEptitudeData(eptitude, card)
        form = eptitude_form(card, data)

    current_site = get_current_site(request)

    context = {"form": form, "card": card, "site": current_site, "site_name": current_site.name}

    return TemplateResponse(request, template_name, context)
Exemple #5
0
def user_role_edit(request, username, membership_id, form_class=GroupMembershipEditForm, template_name="profiles/edit_role.html"):
    user = get_object_or_404(User, username=username)
    membership = get_object_or_404(GroupMembership, id=membership_id)
    
    try:
        profile = Profile.objects.get(user=user)
    except Profile.DoesNotExist:
        profile = Profile.objects.create_profile(user=user)
    
    if not profile.allow_edit_by(request.user):
        raise Http403
    
    if not has_perm(request.user,'user_groups.view_group', membership.group):
        raise Http403
        
    if request.method == 'POST':
        form = form_class(request.POST, instance=membership)
        if form.is_valid():
            form.save()
            messages.add_message(request, messages.SUCCESS, 'Successfully edited membership for %s' % membership.group)
            return HttpResponseRedirect("%s%s" % (reverse('profile', args=[user.username]),'#userview-groups'))
    else:
        form = form_class(instance=membership)

    return render_to_response(template_name, {
                            'form': form,
                            'membership': membership,
                            }, context_instance=RequestContext(request))
Exemple #6
0
    def get(self, request, fid, cid):
        cf = get_object_or_404(ContactField, pk=fid)
        if not perms.c_can_view_fields_cg(request.user.id,
                                          cf.contact_group_id):
            raise PermissionDenied
        fullpath = os.path.join(settings.MEDIA_ROOT, 'fields', fid, cid)
        if not os.path.exists(fullpath):
            raise Http404(_('"{path}" does not exist').format(path=fullpath))
        # Respect the If-Modified-Since header.
        statobj = os.stat(fullpath)
        if not static.was_modified_since(
           request.META.get('HTTP_IF_MODIFIED_SINCE'),
           statobj.st_mtime, statobj.st_size):
            return HttpResponseNotModified()

        # START OF content_type detection
        cfv = get_object_or_404(ContactFieldValue,
                                contact_id=cid, contact_field_id=fid)
        fileinfo = json.loads(cfv.value)
        content_type = fileinfo['content_type']
        # END OF content_type detection

        response = FileResponse(open(fullpath, 'rb'),
                                content_type=content_type)
        response["Last-Modified"] = http_date(statobj.st_mtime)
        if stat.S_ISREG(statobj.st_mode):
            response["Content-Length"] = statobj.st_size

        response['Content-Disposition'] = 'inline; filename="{0}"'.format(
            header_encode(fileinfo['filename'].encode('utf-8'), 'utf-8'))
        return response
Exemple #7
0
def project_index(request, username=None, tag=None):
    """
    The list of projects, which will optionally filter by user or tag,
    in which case a 'person' or 'tag' will be added to the context
    """
    queryset = Project.objects.live()
    if username:
        user = get_object_or_404(User, username=username)
        queryset = queryset.filter(user=user)
    else:
        user = None

    if tag:
        tag = get_object_or_404(Tag, slug=tag)
        queryset = queryset.filter(tags__name__in=[tag.slug])
    else:
        tag = None

    return object_list(
        request,
        queryset=queryset,
        extra_context={'person': user, 'tag': tag},
        page=int(request.GET.get('page', 1)),
        template_object_name='project',
    )
Exemple #8
0
    def __process_activities_badge(self, query, badge, content_object, update_auditted=True):
        content_type = ContentType.objects.get_for_model(content_object)

        cursor = connection.cursor()
        try:
            cursor.execute(query)
            rows = cursor.fetchall()
            
            if update_auditted:
                activity_ids = []
            badge = get_object_or_404(Badge, id=badge)
            for row in rows:
                activity_id = row[0]
                user_id = row[1]
                object_id = row[2]
                
                user = get_object_or_404(User, id=user_id)
                award = Award(user=user, badge=badge, content_type=content_type, object_id=objet_id)
                award.save()
                
                if update_auditted:
                    activity_ids.append(activity_id)
                
            if update_auditted:
                self.update_activities_auditted(cursor, activity_ids)
        finally:
            cursor.close()
Exemple #9
0
def edit_links_edit(request, slug, link):
    link = get_object_or_404(Link, id=link)
    form = project_forms.ProjectLinksForm(request.POST or None, instance=link)
    profile = get_object_or_404(UserProfile, user=request.user)
    project = get_object_or_404(Project, slug=slug)
    if link.project != project:
        return http.HttpResponseForbidden(_("You can't edit this link"))
    metric_permissions = project.get_metrics_permissions(request.user)
    if form.is_valid():
        if link.subscription:
            #links_tasks.UnsubscribeFromFeed.apply_async(args=(link,))
            link.subscription = None
            link.save()
        link = form.save(commit=False)
        link.user = profile
        link.project = project
        link.save()
        messages.success(request, _('Link updated.'))
        return http.HttpResponseRedirect(
            reverse('projects_edit_links', kwargs=dict(slug=project.slug)))
    else:
        form = project_forms.ProjectLinksForm(instance=link)
    return render_to_response('projects/project_edit_links_edit.html', {
        'project': project,
        'form': form,
        'link': link,
        'links_tab': True,
        'can_view_metric_overview': metric_permissions[0],
    }, context_instance=RequestContext(request))
Exemple #10
0
def create_challenge_set_donation(request, template_id, state, club_id, club_class):
    club = get_object_or_404(club_class, id=club_id)
    template = get_object_or_404(ChallengeTemplate, id=template_id)
    form = ChallengeConfigureForm()
    upload_url = blobstore.create_upload_url('/challenges/create/%s/%s/%s/%s' % (
        template_id, state, 'o' if club_class == Club else 't', club_id))
    if request.method == 'POST':
        form = ChallengeConfigureForm(request.POST)
        if form.is_valid():
            uploaded_file = None
            if request.FILES:
                upload_form = UploadForm(request.POST, request.FILES)
                uploaded_file = upload_form.save()
            challenge = _create_challenge(club_class, club_id, form, request, template, image=uploaded_file)
            redirect_url = '/challenges/%s/share' % challenge.id
            if request.is_ajax():
                return HttpResponse(redirect_url)
            return redirect(redirect_url)
        if request.is_ajax():
            return HttpResponse("%s|%s" % (
                blobstore.create_upload_url(upload_url),
                '<br/>'.join(['<br/>'.join([_e for _e in e]) for e in form.errors.values()])))
    template_data = {
        'club': club,
        'club_class': club_class.__name__,
        'form': form,
        'state': state,
        'template': template,
        'upload_url': upload_url}
    return render(
        request,
        'spudderspuds/challenges/pages/create_challenge_configure.html',
        template_data)
Exemple #11
0
def challenge_accept_beneficiary_set_donation(request, participation_id, state, club_id, club_class):
    club = get_object_or_404(club_class, id=club_id)
    participation = get_object_or_404(ChallengeParticipation, id=participation_id)
    challenge = participation.challenge
    template = challenge.template
    form = ChallengeConfigureForm({
        'donation_with_challenge': int(challenge.proposed_donation_amount),
        'donation_without_challenge': int(challenge.proposed_donation_amount_decline)})
    # if request.method == 'POST':
    #     form = ChallengeConfigureForm(request.POST)
    if form.is_valid():
        challenge = _create_challenge(
            club_class, club_id, form, request, template, challenge,
            youtube_video_id=participation.youtube_video_id, image=participation.image)
        return redirect('/challenges/%s/share' % challenge.id)
    template_data = {
        'club': club,
        'club_class': club_class.__name__,
        'form': form,
        'state': state,
        'template': template}
    return render(
        request,
        'spudderspuds/challenges/pages/challenge_accept_beneficiary_choose_donation.html',
        template_data)
 def get_context_data(self, **kwargs):
     context = super(BoardView, self).get_context_data(**kwargs)
     profile_user = get_object_or_404(User, username=kwargs["username"])
     context['profile_user'] = profile_user
     context['board'] = get_object_or_404(Board, slug=kwargs['board_slug'])
     context['pin_form'] = PinForm()
     return context
Exemple #13
0
def appcast(request, pagetype, slug):
    pagetype = get_object_or_404( PageType, folder = pagetype.lower() )
    slug = slug.lower()
    page = get_object_or_404( Page, pagetype__exact = pagetype.id, slug__exact = slug )

    feedclass = feed_engine('rss2')

    server = settings.SITE_URL
    feed = feedclass(
      title = "jerakeen.org / %s / appcast"%page.title,
      link = "%s%s"%( server, page.get_absolute_url() ),
      description = "",
      author_name = "Tom Insam",
      author_email = "*****@*****.**",
      author_link = "http://jerakeen.org/",
      feed_url = "%s%s/appcast"%( server, page.get_absolute_url() ),
    );

    for upload in page.upload_set.all():
        feed.add_item(
            upload.title,
            upload.file.url, # includes hostname
            pagefilter( upload.description ),
            pubdate = upload.date,
            enclosure = feedgenerator.Enclosure( upload.file.url, unicode(upload.file.size), "application/octet-stream" ),
        )
        

    return HttpResponse(
        feed.writeString('utf-8'), mimetype = feed.mime_type )
Exemple #14
0
def move_choose_destination(request, page_to_move_id, viewed_page_id=None):
    page_to_move = get_object_or_404(Page, id=page_to_move_id)
    page_perms = page_to_move.permissions_for_user(request.user)
    if not page_perms.can_move():
        raise PermissionDenied

    if viewed_page_id:
        viewed_page = get_object_or_404(Page, id=viewed_page_id)
    else:
        viewed_page = Page.get_first_root_node()

    viewed_page.can_choose = page_perms.can_move_to(viewed_page)

    child_pages = []
    for target in viewed_page.get_children():
        # can't move the page into itself or its descendants
        target.can_choose = page_perms.can_move_to(target)

        target.can_descend = not(target == page_to_move or target.is_child_of(page_to_move)) and target.get_children_count()

        child_pages.append(target)

    return render(request, 'wagtailadmin/pages/move_choose_destination.html', {
        'page_to_move': page_to_move,
        'viewed_page': viewed_page,
        'child_pages': child_pages,
    })
    def get_region(self, request=None, kwargs=None):
        """
        Returns the Region associated with this view.
        """
        if kwargs is None:
            kwargs = self.kwargs
        if request is None:
            request = self.request

        if kwargs.get('region'):
            region_slug = kwargs.get('region')
            r = get_object_or_404(Region, slug=slugify(region_slug))
        else:
            if self.region_required:
                rs = get_object_or_404(RegionSettings, domain=request.META['HTTP_HOST'])
                r = rs.region
            else:
                if RegionSettings.objects.filter(domain=request.META['HTTP_HOST']).exists():
                    rs = get_object_or_404(RegionSettings, domain=request.META['HTTP_HOST'])
                    r = rs.region
                else:
                    r = None

        if self.region_required and not r.is_active:
            raise Http404(_("Region '%s' was deleted." % r.slug))

        return r
Exemple #16
0
def questions(request, survey_id, question_id=None):
    survey = get_object_or_404(Survey, id=survey_id)
    if request.method == 'GET':
        qs = Question.objects.filter(survey__id=survey_id).order_by('order', 'id')
        return api_utils.response(request, qs, QuestionGrid)
    elif request.method == 'POST':
        form = api_utils.load_form(request, QuestionForm)
        if form.is_valid():
            question = form.save(commit=False)
            question.survey = survey
            if question.order is None:
                res = Question.objects.filter(survey__id=survey_id).aggregate(Max('order'))
                max_order = res['order__max']
                if max_order:
                    question.order = max_order + 1
                else:
                    question.order = 0
            question.save()
            qs = Question.objects.filter(id=question.id)
            return api_utils.response(request, qs, QuestionGrid)
        else:
            return api_utils.response_error(request, form)
    elif request.method == 'DELETE':
        question = get_object_or_404(Question, id=question_id)
        question.delete()
        return api_utils.success()
    raise Http404
Exemple #17
0
    def obj_perms_manage_group_view(self, request, object_pk, group_id):
        """
        Manages selected groups' permissions for current object.
        """
        group = get_object_or_404(Group, id=group_id)
        obj = get_object_or_404(self.queryset(request), pk=object_pk)
        form_class = self.get_obj_perms_manage_group_form()
        form = form_class(group, obj, request.POST or None)

        if request.method == 'POST' and form.is_valid():
            form.save_obj_perms()
            msg = ugettext("Permissions saved.")
            messages.success(request, msg)
            info = (
                self.admin_site.name,
                self.model._meta.app_label,
                self.model._meta.module_name
            )
            url = reverse(
                '%s:%s_%s_permissions_manage_group' % info,
                args=[obj.pk, group.id]
            )
            return redirect(url)

        context = self.get_obj_perms_base_context(request, obj)
        context['group_obj'] = group
        context['group_perms'] = get_perms(group, obj)
        context['form'] = form

        return render_to_response(self.get_obj_perms_manage_group_template(),
            context, RequestContext(request, current_app=self.admin_site.name))
Exemple #18
0
 def __init__(self, user, project_id, stack_ids, x_min, x_max, y_min, y_max,
              z_min, z_max, rotation_cw, zoom_level, single_channel=False,
              output_path=None):
     self.user = user
     self.project_id = int(project_id)
     self.project = get_object_or_404(Project, pk=project_id)
     # Allow a single ID and a list
     if isinstance(stack_ids, int):
         self.stack_ids = [stack_ids]
     else:
         self.stack_ids = stack_ids
     self.stacks = []
     for sid in self.stack_ids:
         self.stacks.append( get_object_or_404(Stack, pk=sid) )
     # The reference stack is used to obtain e.g. resolution information
     self.ref_stack = self.stacks[0]
     self.x_min = float(x_min)
     self.x_max = float(x_max)
     self.y_min = float(y_min)
     self.y_max = float(y_max)
     self.z_min = float(z_min)
     self.z_max = float(z_max)
     self.zoom_level = int(zoom_level)
     # Save a normalized version of the rotation angle
     self.rotation_cw = rotation_cw % 360
     # Create an output path if not already present
     if output_path is None:
         file_name = file_prefix + id_generator() + "." + file_extension
         output_path = os.path.join(crop_output_path, file_name)
     self.single_channel = single_channel
     self.output_path = output_path
     # State that extra initialization is needed
     self.needs_initialization = True
Exemple #19
0
def edit_question(request, survey_id, question_id=None):
    survey = get_object_or_404(Survey, id=survey_id)
    question = get_object_or_404(Question, id=question_id)
    if request.method == 'GET':
        form = QuestionForm(instance=question)
        info = {'id': question.id,
        }
        data = {'info': info,
                'form' : form.as_customized_extjs(question),
        }
        json_data = json.JSONEncoder(ensure_ascii=False).encode({
            'success':True,
            'data': data 
        })
        return utils.JsonResponse(json_data)
    elif request.method == 'POST':
        form = QuestionForm(request.REQUEST, instance=question)
        if form.is_valid():
            question = form.save(commit=False)
            question.survey = survey
            question.save()
            return api_utils.success()
        else:
            return utils.JsonResponse(form.as_extjsdata())          
    raise Http404
Exemple #20
0
def childcare_create(request):
    if request.method == 'POST':
        form = ChildcareCreateForm(request.POST)
        if form.is_valid():
            #managers = form.cleaned_data['managers']
            childcare = form.save(commit=False)
            # check if there is a default theme
            try:
                theme = get_object_or_404(Theme, pk=1)
                theme_exist = True
            except:
                theme_exist = False
            if theme_exist:
                childcare.theme = get_object_or_404(Theme, pk=1)  # set 1st theme as default
            else:
                theme = Theme(title='Default theme', computer_name='default', description='Default theme')
                theme.save()
                childcare.theme = theme
            childcare = form.save(commit=True)
            # automatically add current user as manager and give him permissions
            childcare.managers.add(request.user)
            managers = list(childcare.managers.all())
            # add manager permissions
            group = Group.objects.get(name='Childcare %s: Manager' % childcare.pk)
            for manager in managers:
                manager.groups.add(group)
            # create default classroom
            classroom = Classroom(name='%s classroom' % childcare, childcare=childcare)
            classroom.save()
            log.info(log_prefix+'Childcare created (childcare: %s, user: %s)' % (childcare.name, request.user))
            return HttpResponseRedirect(reverse('childcare:childcare_info', kwargs={'childcare_slug': childcare.slug}))
    else:
        form = ChildcareCreateForm()
    return render(request, 'childcare/childcare_create.html', {'form': form})
Exemple #21
0
def revisions_unschedule(request, page_id, revision_id):
    page = get_object_or_404(Page, id=page_id).specific

    user_perms = UserPagePermissionsProxy(request.user)
    if not user_perms.for_page(page).can_unschedule():
        raise PermissionDenied

    revision = get_object_or_404(page.revisions, id=revision_id)

    next_url = get_valid_next_url_from_request(request)

    subtitle = _('revision {0} of "{1}"').format(revision.id, page.get_admin_display_title())

    if request.method == 'POST':
        revision.approved_go_live_at = None
        revision.save(update_fields=['approved_go_live_at'])

        messages.success(request, _('Revision {0} of "{1}" unscheduled.').format(revision.id, page.get_admin_display_title()), buttons=[
            messages.button(reverse('wagtailadmin_pages:edit', args=(page.id,)), _('Edit'))
        ])

        if next_url:
            return redirect(next_url)
        return redirect('wagtailadmin_pages:revisions_index', page.id)

    return render(request, 'wagtailadmin/pages/revisions/confirm_unschedule.html', {
        'page': page,
        'revision': revision,
        'next': next_url,
        'subtitle': subtitle
    })
Exemple #22
0
def group_message_details(request, group_id, message_id):
    group = get_object_or_404(GroupedMessage, pk=group_id)

    message = get_object_or_404(group.message_set, pk=message_id)
    
    if '__sentry__' in message.data and 'exc' in message.data['__sentry__']:
        module, args, frames = message.data['__sentry__']['exc']
        message.class_name = str(message.class_name)
        # We fake the exception class due to many issues with imports/builtins/etc
        exc_type = type(message.class_name, (Exception,), {})
        exc_value = exc_type(message.message)

        exc_value.args = args
    
        reporter = ImprovedExceptionReporter(message.request, exc_type, exc_value, frames, message.data['__sentry__'].get('template'))
        traceback = mark_safe(reporter.get_traceback_html())
    elif group.traceback:
        traceback = mark_safe('<pre>%s</pre>' % (group.traceback,))
    
    def iter_data(obj):
        for k, v in obj.data.iteritems():
            if k.startswith('_') or k in ['url']:
                continue
            yield k, v

    json_data = iter_data(message)

    page = 'messages'

    return render_to_response('sentry/group/message.html', locals(),
                              context_instance=RequestContext(request))
Exemple #23
0
def write(request, slug_story, activation_key, t='stories/write.html', d={}):
    story = get_object_or_404(Story, slug=slug_story)
    active_membership = story.active_membership()
    d['story']=story
    if not active_membership:
        story.turn_membership()
        return render(request, 'stories/done.html', d)
    membership = get_object_or_404(Membership, activation_key=activation_key)
    if active_membership.id != membership.id:
        return render(request, 'stories/done.html', d)
    new_line = Line(story=story)
    if request.POST:
        line_form=LineForm(request.POST, prefix='line', instance=new_line)
        if line_form.is_valid():
            line_form.save()
            next = story.turn_membership()
            mail_d = {
                'story': story,
                'site': get_current_site(request)
            }
            message = render_to_string('stories/email.txt', mail_d)
            email = EmailMessage(
                'Estas participando del concurso',
                message,
                to=[next.user.email])
            email.send()
            return render(request, 'stories/done.html', d)  
    else:
        line_form=LineForm(prefix='line')
    d = {
        'form': line_form,
        'story': story,
        'site': get_current_site(request)
    }
    return render(request, t, d)
Exemple #24
0
def user_page(request, user):
    '''
    User details page.
    '''
    user = get_object_or_404(User, username=user)
    profile = get_object_or_404(Profile, user=user)

    # Filter all user activity
    all_changes = Change.objects.last_changes(request.user).filter(
        user=user,
    )

    # Last user activity
    last_changes = all_changes[:10]

    # Filter where project is active
    user_projects_ids = set(all_changes.values_list(
        'translation__subproject__project', flat=True
    ))
    user_projects = Project.objects.filter(id__in=user_projects_ids)

    return render(
        request,
        'accounts/user.html',
        {
            'page_profile': profile,
            'page_user': user,
            'last_changes': last_changes,
            'last_changes_url': urlencode(
                {'user': user.username.encode('utf-8')}
            ),
            'user_projects': user_projects,
        }
    )
def buy_now(request, id):
    if request.method == 'POST':
        print(request.POST)
        form = MakePaymentForm(request.POST)
        if form.is_valid():
            try:
                product = get_object_or_404(Products, pk=id)
                customer = stripe.Charge.create(
                    amount= int(product.price * 100),
                    currency="EUR",
                    description=product.name,
                    card=form.cleaned_data['stripe_id'],
                )
            except (stripe.error.CardError, e):
                messages.error(request, "Your card was declined!")

            if customer.paid:
                messages.success(request, "You have successfully paid")
                return redirect(reverse('products'))
            else:
                messages.error(request, "Unable to take payment")
        else:
            messages.error(request, "We were unable to take a payment with that card!")

    else:
        form = MakePaymentForm()
        product = get_object_or_404(Products, pk=id)

    args = {'form': form, 'publishable': settings.STRIPE_PUBLISHABLE_KEY, 'product': product}
    args.update(csrf(request))

    return render(request, 'pay.html', args)
Exemple #26
0
def group_delete(request, group_id=None, group_id_list=None):
    check_permissions(request.user, [PERMISSION_GROUP_DELETE])
    post_action_redirect = None

    if group_id:
        groups = [get_object_or_404(Group, pk=group_id)]
        post_action_redirect = reverse('group_list')
    elif group_id_list:
        groups = [get_object_or_404(Group, pk=group_id) for group_id in group_id_list.split(',')]
    else:
        messages.error(request, _(u'Must provide at least one group.'))
        return HttpResponseRedirect(request.META.get('HTTP_REFERER', '/'))

    previous = request.POST.get('previous', request.GET.get('previous', request.META.get('HTTP_REFERER', '/')))
    next = request.POST.get('next', request.GET.get('next', post_action_redirect if post_action_redirect else request.META.get('HTTP_REFERER', '/')))

    if request.method == 'POST':
        for group in groups:
            try:
                group.delete()
                messages.success(request, _(u'Group "%s" deleted successfully.') % group)
            except Exception, e:
                messages.error(request, _(u'Error deleting group "%(group)s": %(error)s') % {
                    'group': group, 'error': e
                })

        return HttpResponseRedirect(next)
Exemple #27
0
def user_delete(request, user_id=None, user_id_list=None):
    check_permissions(request.user, [PERMISSION_USER_DELETE])
    post_action_redirect = None

    if user_id:
        users = [get_object_or_404(User, pk=user_id)]
        post_action_redirect = reverse('user_list')
    elif user_id_list:
        users = [get_object_or_404(User, pk=user_id) for user_id in user_id_list.split(',')]
    else:
        messages.error(request, _(u'Must provide at least one user.'))
        return HttpResponseRedirect(request.META.get('HTTP_REFERER', '/'))

    previous = request.POST.get('previous', request.GET.get('previous', request.META.get('HTTP_REFERER', '/')))
    next = request.POST.get('next', request.GET.get('next', post_action_redirect if post_action_redirect else request.META.get('HTTP_REFERER', '/')))

    if request.method == 'POST':
        for user in users:
            try:
                if user.is_superuser or user.is_staff:
                    messages.error(request, _(u'Super user and staff user deleting is not allowed, use the admin interface for these cases.'))
                else:
                    user.delete()
                    messages.success(request, _(u'User "%s" deleted successfully.') % user)
            except Exception, e:
                messages.error(request, _(u'Error deleting user "%(user)s": %(error)s') % {
                    'user': user, 'error': e
                })

        return HttpResponseRedirect(next)
Exemple #28
0
def permissions_import_json(request, ufp_id=0):
    upload_file = request.FILES.get('perms_upload')

    if upload_file:
        try:
            perms = json.loads(upload_file.read().decode('utf-8'))
            username = perms.get('username')

            if ufp_id:
                ufp = get_object_or_404(UserFieldPermissions, pk=ufp_id)
                if username == ufp.user.username:
                    # Delete the old field permissions
                    ufp.permissions.all().delete()
                    _add_permissions(request, ufp, perms)
                else:
                    message = 'The wrong user is defined in the imported file'
                    messages.add_message(request, messages.ERROR, message)
            else:
                user = get_object_or_404(User, username=username)
                ufp = UserFieldPermissions(user=user)
                ufp.save()
                _add_permissions(request, ufp, perms)
                ufp_id = ufp.pk
        except Exception as e:
            message = 'Error in the import : %s' % e
            messages.add_message(request, messages.ERROR, message)
    else:
        message = 'Missing imported file'
        messages.add_message(request, messages.ERROR, message)

    return redirect(
        '/admin/rest_framework_fine_permissions/userfieldpermissions/%s'\
            % ufp_id)
Exemple #29
0
def candidatelist_edit(request, candidatelist_id=None, entity_id=None):

    if not entity_id:
        entity = request.user.profile.locality
    else:
        entity = get_object_or_404(Entity, id=entity_id)

    if candidatelist_id:
        candidatelist = get_object_or_404(CandidateList, id=candidatelist_id)
    else:
        candidatelist = CandidateList(entity=entity)


    if not candidatelist.can_edit(request.user):
        return HttpResponseForbidden(_("Only editors have access to this page."))

    if request.method == "POST":
        form = CandidateListForm(request.POST, instance=candidatelist)
        if form.is_valid():
            form.save()
            return HttpResponseRedirect(reverse('candidate-list', kwargs={'candidatelist_id': candidatelist.id}))
    else:
        form = CandidateListForm(instance=candidatelist)

    context = RequestContext(request, {'form': form,
                                       'entity': entity,
                                       'candidatelist_id': candidatelist_id,
                                      })
    return render(request, "polyorg/candidatelist_form.html", context)
Exemple #30
0
def channel(request, slug_c, slug_t=None):
    channel = get_object_or_404(Channel, slug=slug_c)
    theme = None

    videos_list = VIDEOS.filter(channel=channel)

    if slug_t:
        theme = get_object_or_404(Theme, slug=slug_t)
        videos_list = videos_list.filter(theme=theme)

    order_by = request.COOKIES.get('orderby') if request.COOKIES.get(
        'orderby') else "order_by_-date_added"
    videos_list = videos_list.order_by(
        "%s" % replace(order_by, "order_by_", ""))

    #per_page = request.GET.get('per_page') if request.GET.get('per_page') and request.GET.get('per_page').isdigit() else DEFAULT_PER_PAGE
    per_page = request.COOKIES.get('perpage') if request.COOKIES.get(
        'perpage') and request.COOKIES.get('perpage').isdigit() else DEFAULT_PER_PAGE
    paginator = Paginator(videos_list, per_page)
    page = request.GET.get('page')

    videos = get_pagination(page, paginator)

    if request.is_ajax():
        return render_to_response("videos/videos_list.html",
                                  {"videos": videos},
                                  context_instance=RequestContext(request))

    return render_to_response("channels/channel.html",
                              {"channel": channel, "theme": theme,
                                  "videos": videos},
                              context_instance=RequestContext(request))
Exemple #31
0
def dataset_explore(request, short_name):
    dataset = get_object_or_404(Dataset, short_name=short_name)

    return render(request, 'datasets/dataset_explore.html', {
        'dataset': dataset,
    })
Exemple #32
0
def deletar_email(request, pk):
    email = get_object_or_404(Email, pk=pk)
    email.delete()
    return redirect('cliente:cliente', pk=email.client.id)
Exemple #33
0
def inquery_car(request, car_id):
    car = get_object_or_404(Car, pk=car_id)
    context = {'car': car}
    return render(request, "page/inquery-car.html", context)
Exemple #34
0
def inquery_tour(request, tour_id):
    tour = get_object_or_404(Tour, pk=tour_id)
    context = {'tour': tour}
    return render(request, "page/inquery-tour.html", context)
Exemple #35
0
def inquery_hotel(request, hotel_id):
    hotel = get_object_or_404(Hotel, pk=hotel_id)
    context = {'hotel': hotel}
    return render(request, "page/inquery-hotel.html", context)
Exemple #36
0
def dataset_sounds(request, short_name):
    dataset = get_object_or_404(Dataset, short_name=short_name)
    return JsonResponse({'sounds': [s.id for s in dataset.sounds.all()]})
Exemple #37
0
def dataset_taxonomy_tree(request, short_name):
    dataset = get_object_or_404(Dataset, short_name=short_name)
    taxonomy_tree = dataset.taxonomy.get_taxonomy_as_tree()
    return JsonResponse(taxonomy_tree)
Exemple #38
0
def choose_category(request, short_name):
    dataset = get_object_or_404(Dataset, short_name=short_name)
    request.session['read_instructions'] = True
    request.session['nb_task1_pages'] = 0
    return render(request, 'datasets/dataset_taxonomy_choose_category.html',
                  {'dataset': dataset})
Exemple #39
0
def explore_taxonomy(request, short_name):
    dataset = get_object_or_404(Dataset, short_name=short_name)
    return render(request, 'datasets/explore_taxonomy.html',
                  {'dataset': dataset})
Exemple #40
0
def dataset_taxonomy_table_choose(request, short_name):
    if not request.user.is_authenticated:
        return HttpResponse('Unauthorized', status=401)
    dataset = get_object_or_404(Dataset, short_name=short_name)
    taxonomy = dataset.taxonomy
    hierarchy_paths = []
    end_of_table = False
    add_label_or_choose_category = request.POST.get(
        'add_label_or_choose_category', 'choose_category')

    # nodes for Free choose table
    if request.method == 'POST':
        node_id = request.POST['node_id']

        # choose a category at the given node_id level
        if node_id != str(0):
            if node_id in [
                    node.node_id for node in taxonomy.get_nodes_at_level(0)
            ]:
                # remove node that them and all their children are omitted.
                # Here we should remove also the categories which all its children have no more annotations tu validate.
                # Doing it with dataset.get_categories_to_validate() or with dataset.user_can_annotated() on all
                # children would be too slow
                if add_label_or_choose_category == 'choose_category':
                    nodes = [
                        node for node in taxonomy.get_children(node_id)
                        if node.self_and_children_advanced_task
                        and not node.self_and_children_omitted
                    ]
                else:
                    nodes = [node for node in taxonomy.get_children(node_id)]
            else:
                end_of_table = True  # end of continue, now the user will choose a category to annotate
                nodes = list(taxonomy.get_all_children(node_id)) + [taxonomy.get_element_at_id(node_id)] \
                    + list(taxonomy.get_all_parents(node_id))
                # we should remove the nodes that have no more annotations to validate for the user
                # by using dataset.user_can_annotate(), but it is too slow
                if add_label_or_choose_category == 'choose_category':
                    nodes = [
                        node for node in nodes
                        if node.advanced_task and not node.omitted
                    ]
                else:
                    pass
            hierarchy_paths = dataset.taxonomy.get_hierarchy_paths(node_id)

        # start choosing category
        else:
            nodes = taxonomy.get_nodes_at_level(0)
            nodes = [
                node for node in nodes if node.self_and_children_advanced_task
                and not node.self_and_children_omitted
            ]
        nodes = sorted(nodes, key=lambda n: n.nb_ground_truth)

    # GET request, nodes for Our priority table
    else:
        end_of_table = True
        nodes = dataset.get_categories_to_validate(request.user).filter(advanced_task=True)\
            .exclude(omitted=True).order_by('nb_ground_truth')[:20]

    return render(
        request, 'datasets/dataset_taxonomy_table_choose.html', {
            'dataset': dataset,
            'end_of_table': end_of_table,
            'hierarchy_paths': hierarchy_paths,
            'nodes': nodes,
            'add_label_or_choose_category': add_label_or_choose_category
        })
Exemple #41
0
def deletetodo(request, todo_pk):
	todo = get_object_or_404(Todo, pk = todo_pk,user = request.user)
	if request.method == 'POST':
		
		todo.delete()
		return redirect('currenttodos')
Exemple #42
0
def contribute_validate_annotations_category(request,
                                             short_name,
                                             node_id,
                                             html_url=None):
    NB_TOTAL_ANNOTATIONS = 12
    dataset = get_object_or_404(Dataset, short_name=short_name)
    user = request.user
    user_is_maintainer = dataset.user_is_maintainer(user)
    user_last_category = user.profile.last_category_annotated
    node_id = unquote(node_id)
    node = dataset.taxonomy.get_element_at_id(node_id)
    skip_tempo = True if user_last_category == node and user.profile.contributed_recently or \
                         request.GET.get(settings.SKIP_TEMPO_PARAMETER, False) else False
    maintainer_task = request.GET.get('mt', 0)
    new_annotations = request.GET.get(
        'na', 0)  # new annotations (for Kaggle dataset)

    annotation_ids = []
    # check if user annotate a new category or has not annotate for a long time
    # make him fail the test and reset countdown
    if user_last_category != node or not user.profile.contributed_recently:
        user.profile.test = 'FA'
        user.profile.refresh_countdown()

    user_test = user.profile.test
    sound_examples_verification = node.freesound_examples_verification.all(
    ).filter(deleted_in_freesound=False)
    annotation_examples_verification_ids = dataset.candidate_annotations.filter(
        sound_dataset__sound__in=sound_examples_verification,
        taxonomy_node=node).values_list('id', flat=True)

    sound_examples = node.freesound_examples.all().filter(
        deleted_in_freesound=False)
    annotation_examples_ids = dataset.candidate_annotations.filter(sound_dataset__sound__in=sound_examples, taxonomy_node=node)\
        .values_list('id', flat=True)

    if node.positive_verification_examples_activated:
        # Check if user has passed the test to know if it is needed to add test examples to the form
        if user_test == 'FA':
            N_verification_examples = min(
                2, len(annotation_examples_verification_ids))
            annotation_ids += random.sample(
                list(annotation_examples_verification_ids),
                N_verification_examples)

    negative_annotation_example = False
    if node.negative_verification_examples_activated:
        # Get negative examples and add one if user has failed the test
        if user_test == 'FA':
            negative_sound_examples = node.freesound_false_examples.filter(
                deleted_in_freesound=False).order_by('?')
            if negative_sound_examples:
                negative_sound_example = negative_sound_examples[0]
                # create "dummy" annotation example for the false example of id 0 (the corresponding annotation does
                # not exist in the Annotation table because it is a false irrelevant example)
                negative_annotation_example = CandidateAnnotation(
                    sound_dataset=SoundDataset(sound=negative_sound_example,
                                               dataset=dataset),
                    id=0)
                annotation_ids += [
                    None
                ]  # count as an added annotation but does not retrieve any annotation later,
                #  the false annotation "negative_annotation_example" is added manually

    # Get non ground truth annotations, never voted by the user (with positive test),
    # exclude test examples, order by priority score & random,
    # exclude candidate outside of [0.3, 30] sec and with 0 votes
    # TODO: put this in a class method and do a test
    annotations = dataset.non_ground_truth_annotations_per_taxonomy_node(node_id)\
                         .exclude(id__in=Vote.objects.filter(candidate_annotation__taxonomy_node=node,
                                                             created_by=user,
                                                             test__in=('UN', 'AP', 'PP', 'NA', 'NP'))
                                  .values('candidate_annotation_id'))\
                         .exclude(id__in=annotation_examples_verification_ids)\
                         .exclude(id__in=annotation_examples_ids)\
                         .filter(sound_dataset__sound__deleted_in_freesound=False)\
                         .order_by('-priority_score', '?')

    # Exclude annotations that have votes (for kaggle dataset) and that have nc and sampling+ licenses
    if new_annotations == '1':
        # this will discard the annotations with no votes
        # out of [0.3, 30] secondes
        # and with NC licenses
        annotations = annotations\
            .exclude(priority_score__gte=1000)\
            .exclude(priority_score__lte=100)\
            .exclude(sound_dataset__sound__extra_data__license__in=('http://creativecommons.org/licenses/by-nc/3.0/',
                                                                    'http://creativecommons.org/licenses/sampling+/1.0/'
                                                                    ))

    N_ANNOTATIONS_TO_VALIDATE = NB_TOTAL_ANNOTATIONS - len(annotation_ids)
    annotation_ids += annotations[:N_ANNOTATIONS_TO_VALIDATE].values_list(
        'id', flat=True)

    # If not candidate annotations left, remove test annotations
    if annotations.count() == 0:
        annotation_ids = list()
        negative_annotation_example = list()

    # Get the selected annotations
    N = len(annotation_ids)
    annotations_to_validate = list(
        CandidateAnnotation.objects.filter(
            id__in=annotation_ids).select_related('sound_dataset__sound'))
    if negative_annotation_example:  # add the "dummy" negative example annotation if it exists
        annotations_to_validate.append(negative_annotation_example)
    random.shuffle(annotations_to_validate)

    formset = PresentNotPresentUnsureFormSet(
        initial=[{
            'annotation_id': annotation.id
        } for annotation in annotations_to_validate])
    annotations_forms = list(zip(list(annotations_to_validate), formset))

    category_comment_form = CategoryCommentForm()

    nb_task1_pages = request.session.get('nb_task1_pages', False)
    if not nb_task1_pages or nb_task1_pages > 6 or user_last_category != node:
        request.session['nb_task1_pages'] = 1
        nb_task1_pages = 1

    # For beginner task html_url argument is given
    if not html_url:
        html_url = 'datasets/contribute_validate_annotations_category.html'

    return render(
        request, html_url, {
            'dataset': dataset,
            'node': node,
            'annotations_forms': annotations_forms,
            'formset': formset,
            'N': N,
            'user_is_maintainer': user_is_maintainer,
            'category_comment_form': category_comment_form,
            'skip_tempo': skip_tempo,
            'skip_tempo_parameter': settings.SKIP_TEMPO_PARAMETER,
            'nb_task1_pages': nb_task1_pages,
            'maintainer_task': maintainer_task,
            'new_annotations': new_annotations
        })
Exemple #43
0
 def get_project(project_id):
     return get_object_or_404(Project, pk=project_id)
Exemple #44
0
def completetodo(request, todo_pk):
	todo = get_object_or_404(Todo, pk = todo_pk,user = request.user)
	if request.method == 'POST':
		todo.datecompleted = timezone.now()
		todo.save()
		return redirect('currenttodos')
Exemple #45
0
def facture_detail_view(request, pk):
    facture = get_object_or_404(Facture, id=pk)
    context = {}
    context['facture'] = facture
    return render(request, 'facture_detail.html', context)
Exemple #46
0
 def dispatch(self, request, article, attachment_id, *args, **kwargs):
     self.attachment = get_object_or_404(
         models.Attachment.objects.active().can_write(request.user),
         id=attachment_id)
     return super().dispatch(request, article, *args, **kwargs)
Exemple #47
0
def delete(request, blog_id):
    blog_delete = get_object_or_404(Blog, pk = blog_id)
    blog_delete.delete()
    return redirect('home')
Exemple #48
0
def detail(request, blog_id):
	detailblog = get_object_or_404(Blog, pk=blog_id)
	return render(request, 'blog/detail.html', {'blog':detailblog}) 
def results(request, question_id):
    question = get_object_or_404(Question, pk=question_id)
    return render(request, 'polls/results.html', {'question': question})
Exemple #50
0
def update(request, blog_id):
    blog_update = get_object_or_404(Blog, pk = blog_id)
    return render(request, "update.html", {"blogupdate" : blog_update})
Exemple #51
0
def delete(request, pk):
    blog = get_object_or_404(Blog, pk=pk)
    blog.delete()
    return redirect('home')
Exemple #52
0
def detail(request, blog_id):
    blog_detail = get_object_or_404(Blog, pk = blog_id)
    return render(request, "detail.html", {"blog" : blog_detail})
Exemple #53
0
def category_delete(request, categoryid):
    category = get_object_or_404(Category, id=categoryid)
    category.delete()
    return redirect('post:categorylist')
def detail(request, question_id):
    question = get_object_or_404(Question, pk=question_id)
    return render(request, 'polls/detail.html', {'question': question})
Exemple #55
0
def comment_delete(request, commentid):
    comment = get_object_or_404(Comment, id=commentid)
    comment.delete()
    return redirect('post:index')
Exemple #56
0
def post_detail(request, pk):
    post = get_object_or_404(Post, pk=pk)
    return render(request, 'blog/post_detail.html', {'post': post})
Exemple #57
0
 def get_object(self):  # pobiera obiekt id
     id_ = self.kwargs.get("id")  # pobieranie adresu id
     return get_object_or_404(Article, id=id_)
Exemple #58
0
def category(request, categoryid):
    category = get_object_or_404(Category, id=categoryid)
    category_objects = category.post_set.all()
    return render(request, 'post/categorydetail.html',
                  {'category': category_objects})
Exemple #59
0
 def get_object(self):
     id_ = self.kwargs.get("id")  # przekazywane addresy id
     return get_object_or_404(Article, id=id_)
Exemple #60
0
 def get_object(self):
     id_ = self.kwargs.get("id")
     return get_object_or_404(Article, id=id_)