Python django.contrib.messages.error() Examples

def delete_product(request, pk, group):
    from django.db.models import ProtectedError
    product = get_object_or_404(Product, pk=pk)

    if request.method == 'POST':
        try:
            product.delete()
            Inventory.objects.filter(product=product).delete()
            messages.success(request, _("Product deleted"))
        except ProtectedError:
            messages.error(request, _('Cannot delete product'))

        return redirect(list_products, group)

    action = request.path
    return render(request, 'products/remove.html', locals()) 

def dispatch(self, *args, **kwargs):
        profile = Profile.get_or_create_for_user(self.request.user)
        if not profile.allow_add_item():
            messages.error(self.request, _('You have reached the limit!'))
            return redirect(reverse('django_classified:user-items'))

        return super(ItemCreateView, self).dispatch(*args, **kwargs) 

def remove_product(request, pk, item_id):
    order = get_object_or_404(Order, pk=pk)

    # The following is to help those who hit Back after removing a product
    try:
        item = ServiceOrderItem.objects.get(pk=item_id)
    except ServiceOrderItem.DoesNotExist:
        messages.error(request, _("Order item does not exist"))
        return redirect(order)

    if request.method == 'POST':
        msg = order.remove_product(item, request.user)
        messages.info(request, msg)
        return redirect(order)

    return render(request, 'orders/remove_product.html', locals()) 

def draw_prize_winners(request):
        currentEvent = viewutil.get_selected_event(request)
        params = {'feed': 'todraw'}
        if currentEvent is not None:
            params['event'] = currentEvent.id
        prizes = search_filters.run_model_query('prize', params, user=request.user)
        if request.method == 'POST':
            form = forms.DrawPrizeWinnersForm(prizes=prizes, data=request.POST)
            if form.is_valid():
                for prize in form.cleaned_data['prizes']:
                    status = True
                    while status and not prize.maxed_winners():
                        status, data = prizeutil.draw_prize(
                            prize, seed=form.cleaned_data['seed']
                        )
                        prize.error = data['error'] if not status else ''
                    logutil.change(request, prize, 'Prize Drawing')
                return render(
                    request,
                    'admin/draw_prize_winners_post.html',
                    {'prizes': form.cleaned_data['prizes']},
                )
        else:
            form = forms.DrawPrizeWinnersForm(prizes=prizes)
        return render(request, 'admin/draw_prize_winners.html', {'form': form}) 

def find_device(request):
    device = Device(sn=request.GET['sn'])
    device.description = _('Other Device')
    device_form = forms.DeviceForm(instance=device)

    try:
        apple_sn_validator(device.sn)
    except Exception as e:  # not an Apple serial number
        return render(request, "checkin/device_form.html", locals())

    try:
        device = get_device(request, device.sn)
        device_form = forms.DeviceForm(instance=device)
    except GsxError as e:
        error = e

    return render(request, "checkin/device_form.html", locals()) 

def edit_calendar(request, pk=None, view="week"):
    from servo.models.calendar import CalendarForm
    calendar = Calendar(user=request.user)

    if pk:
        calendar = get_object_or_404(Calendar, pk=pk)
        if not calendar.user == request.user:
            messages.error(request, _('You can only edit your own calendar'))
            return redirect(calendars)

    if request.method == "POST":
        form = CalendarForm(request.POST, instance=calendar)

        if form.is_valid():
            calendar = form.save()
            messages.success(request, _("Calendar saved"))
            return redirect(view_calendar, calendar.pk, 'week')

    form = CalendarForm(instance=calendar)

    data = {'title': calendar.title}
    data['form'] = form
    data['action'] = request.path

    return render(request, "accounts/calendar_form.html", data) 

def print_all_contracts(request, unit_slug, semester):
    hiring_semester = get_object_or_404(HiringSemester,
                                        semester__name=semester,
                                        unit__in=request.units,
                                        unit__label=unit_slug)
    contracts = TAContract.objects.signed(hiring_semester).order_by('person__last_name', 'person__first_name')
    # If no one has ever checked the 'I've verified the visa info for this person'
    # box, let's stop them from printing.  We don't want to send this anywhere, but
    # it's just for our own peace of mind.
    not_verified=[]
    for c in contracts:
        if not c.visa_verified:
            not_verified.append(c.person.name())
    if not_verified:
        messages.error(request, 'You must verify the TA\'s visa information before printing for the following people: ')
        for name in not_verified:
            messages.error(request, name)
        return HttpResponseRedirect(reverse('tacontracts:list_all_contracts',
                                            kwargs={'unit_slug': unit_slug,
                                                    'semester': semester,}))
    response = HttpResponse(content_type="application/pdf")
    response['Content-Disposition'] = 'inline; filename="tacontracts-%s-%s.pdf"' % (hiring_semester, unit_slug)
    tacontract_forms(contracts, response)
    return response 

def reopen_submission(request, form_slug, formsubmit_slug):
    # The wording here is tricky.  The _formsubmission_find_and_authz method only returns "is_advisor" if you are
    # *only* an advisor, but not in the form group that owns the form.  If you are in the form group, is_advisor is
    # false, and form_submission will be the instance we want to work on.
    form_submission, is_advisor = _formsubmission_find_and_authz(request, form_slug, formsubmit_slug)
    if not form_submission:
        raise Http404
    # Therefore, if you're not a supervisor and you had a form_submission returned, you're in the form group and
    # can re-open it.
    can_reopen = not is_advisor and form_submission.status == 'DONE'
    if can_reopen and request.method == 'POST':
        form_submission.reopen(requester=request.user.username)
        messages.success(request, "Form re-opened")
        l = LogEntry(userid=request.user.username,
                     description=("Re-opened Form Submission %s") % form_submission,
                     related_object=form_submission)
        l.save()
    else:
        messages.error(request, "The form could no be re-opened.  Perhaps it was already re-opened, or you do not "
                                "have permission to perform this action.")
    return HttpResponseRedirect(reverse('onlineforms:view_submission', kwargs={'form_slug': form_slug,
                                                                               'formsubmit_slug': formsubmit_slug})) 

def new_grade_source(request):
    data = {
        "grade_source_form": GradeSourceForm(),
    }

    if request.method == "POST":
        form = GradeSourceForm(request.POST)
        if form.is_valid():
            instance = form.save(commit=False)
            instance.save()
            return HttpResponseRedirect(reverse('grade_source_index'))
        else:
            messages.error(request, "Please correct the error below")
            form = GradeSourceForm(form.data)
            data.update({
                "grade_source_form": form,
            })

    return data 

def add_combined_offering(request, pk):
    combined = get_object_or_404(CombinedOffering, pk=pk)
    if request.method == 'POST':
        form = OneOfferingForm(request.POST)
        if form.is_valid():
            offering = form.cleaned_data['offering']
            if offering in combined.offerings.all():
                messages.error(request, 'That offering is already in the combined section.')
            else:
                combined.offerings.add(offering)
                combined.create_combined_offering()
                #LOG EVENT#
                l = LogEntry(userid=request.user.username,
                      description=("added %s to combined offering %i") % (offering.slug, combined.id),
                      related_object=combined)
                l.save()
                messages.success(request, 'Added offering.')
                return HttpResponseRedirect(reverse('sysadmin:combined_offerings', kwargs={}))
    else:
        form = OneOfferingForm()

    context = {
        'form': form,
    }
    return render(request, 'coredata/add_combined_offering.html', context) 

def status(request):
    """Check service order status through the checkin."""
    title = _('Repair Status')

    if request.GET.get('code'):
        timeline = []
        form = forms.StatusCheckForm(request.GET)
        if form.is_valid():
            code = form.cleaned_data['code']
            try:
                order = Order.objects.get(code=code)
                status_description = order.get_status_description()
                if Configuration.conf('checkin_timeline'):
                    timeline = order.orderstatus_set.all()
                if order.status is None:
                    order.status_name = _(u'Waiting to be processed')
            except Order.DoesNotExist:
                messages.error(request, _(u'Order %s not found') % code)
            return render(request, "checkin/status-show.html", locals())
    else:
        form = forms.StatusCheckForm()

    return render(request, "checkin/status.html", locals()) 

def edit_group(request, group='all'):
    if group == 'all':
        group = CustomerGroup()
    else:
        group = CustomerGroup.objects.get(slug=group)

    title = group.name
    form = GroupForm(instance=group)

    if request.method == "POST":
        form = GroupForm(request.POST, instance=group)
        if form.is_valid():
            group = form.save()
            messages.success(request, _(u'%s saved') % group.name)
            return redirect(index, group.slug)
        messages.error(request, form.errors['name'][0])
        return redirect(index)

    return render(request, "customers/edit_group.html", locals()) 

def print_contract(request, unit_slug, semester, contract_slug):
    hiring_semester = get_object_or_404(HiringSemester, 
                                        semester__name=semester, 
                                        unit__in=request.units,
                                        unit__label=unit_slug)
    contract = get_object_or_404(TAContract,
                                 category__hiring_semester=hiring_semester,
                                 slug=contract_slug,
                                 category__account__unit__in=request.units)
    # If no one has ever checked the 'I've verified the visa info for this person'
    # box, let's stop them from printing.  We don't want to send this anywhere, but
    # it's just for our own peace of mind.
    if not contract.visa_verified:
        messages.error(request, 'You must verify the TA\'s visa information before printing')
        return HttpResponseRedirect(reverse('tacontracts:view_contract',
                                            kwargs={'unit_slug': unit_slug,
                                                    'semester': semester,
                                                    'contract_slug': contract_slug}))
    response = HttpResponse(content_type="application/pdf")
    response['Content-Disposition'] = 'inline; filename="%s-%s.pdf"' % \
                                        (contract.slug, contract.person.userid)
    tacontract_form(contract, response)
    return response 

def calculate_all_lettergrades(request, course_slug, activity_slug):
    course = get_object_or_404(CourseOffering, slug=course_slug)
    activity = get_object_or_404(CalLetterActivity, slug=activity_slug, offering=course, deleted=False)
    
    try:
        ignored = calculate_letter_grade(course,activity)
        if ignored==1:
            messages.warning(request, "Did not calculate letter grade for 1 manually-graded student.")
        elif ignored>1:
            messages.warning(request, "Did not calculate letter grade for %i manually-graded students." % (ignored))
    except ValidationError as e:
        messages.error(request, e.args[0])
    except NotImplementedError:
        return NotFoundResponse(request)

    return HttpResponseRedirect(activity.get_absolute_url()) 

def delete_calendar(request, pk):
    calendar = get_object_or_404(Calendar, pk=pk)

    if calendar.user != request.user:
        messages.error(request, _("Users can only delete their own calendars!"))

        return redirect(calendars)

    if request.method == "POST":
        calendar.delete()
        messages.success(request, _('Calendar deleted'))
        return redirect(calendars)

    data = {'title': _("Really delete this calendar?")}
    data['action'] = request.path

    return render(request, "accounts/delete_calendar.html", data) 

def delete_device(request, product_line, model, pk):
    dev = get_object_or_404(Device, pk=pk)

    if request.method == 'POST':
        from django.db.models import ProtectedError
        try:
            dev.delete()
            messages.success(request, _("Device deleted"))
        except ProtectedError:
            messages.error(request, _("Cannot delete device with GSX repairs"))
            return redirect(dev)

        return redirect(index)

    data = {'action': request.path}
    data['device'] = dev

    return render(request, "devices/remove.html", data) 

def update_gsx_details(request, pk):
    """
    Updates devices GSX warranty details
    """
    device = get_object_or_404(Device, pk=pk)
    try:
        GsxAccount.default(request.user)
        device.update_gsx_details()
        messages.success(request, _("Warranty status updated successfully"))
    except Exception as e:
        messages.error(request, e)

    if request.session.get('return_to'):
        return redirect(request.session['return_to'])

    return redirect(device) 

def close(request, pk):
    """Close this Service Order."""
    order = get_object_or_404(Order, pk=pk)

    if request.method == 'POST':
        try:
            order.close(request.user)
        except Exception as e:
            messages.error(request, e)
            return redirect(order)

        if request.session.get("current_order_id"):
            del(request.session['current_order_id'])
            del(request.session['current_order_code'])
            del(request.session['current_order_customer'])

        messages.success(request, _('Order %s closed') % order.code)

        return redirect(order)

    data = {'order': order, 'action': reverse(close, args=[pk])}
    return render(request, "orders/close.html", data) 

def draw_prize_internal(self, request, queryset, limit):
        numDrawn = 0
        for prize in queryset:
            if prize.key_code:
                drawn, msg = prizeutil.draw_keys(prize)
                if drawn:
                    numDrawn += len(msg['winners'])
                else:
                    messages.error(request, msg['error'])
            else:
                if limit is None:
                    limit = prize.maxwinners
                numToDraw = min(limit, prize.maxwinners - prize.current_win_count())
                drawingError = False
                while not drawingError and numDrawn < numToDraw:
                    drawn, msg = prizeutil.draw_prize(prize)
                    if not drawn:
                        self.message_user(request, msg['error'], level=messages.ERROR)
                        drawingError = True
                    else:
                        numDrawn += 1
        if numDrawn > 0:
            self.message_user(request, '%d prizes drawn.' % numDrawn) 

def remove_user(request, pk, user_id):
    """
    Removes this user from the follower list, unsets assignee
    """
    order = get_object_or_404(Order, pk=pk)
    user  = get_object_or_404(User, pk=user_id)

    try:
        order.remove_follower(user)
        if user == order.user:
            order.set_user(None, request.user)
        msg = _('User %s removed from followers') % user
        order.notify("unset_user", msg, request.user)
    except Exception as e:
        messages.error(request, e)

    return redirect(order) 

def device_from_product(request, pk, item_id):
    """
    Turns a SOI into a device and attaches it to this order
    """
    order = get_object_or_404(Order, pk=pk)
    soi = ServiceOrderItem.objects.get(pk=item_id)

    try:
        GsxAccount.default(request.user, order.queue)
        device = Device.from_gsx(soi.sn, user=request.user)
        device.save()
        event = order.add_device(device, request.user)
        messages.success(request, event)
    except Exception as e:
        messages.error(request, e)

    return redirect(order) 

def upload_users(request):
    """
    """
    action = request.path
    form = UserUploadForm()
    title = _('Upload Users')

    if request.method == 'POST':
        form = UserUploadForm(request.POST, request.FILES)
        if form.is_valid():
            try:
                users = form.save()
                messages.success(request, _('%d users imported') % len(users))
            except Exception as e:
                messages.error(request, e)
        else:
            messages.error(request, form.errors)

        return redirect(list_users)

    return render(request, "admin/users/upload_users.html", locals()) 

def delete_location(request, pk):
    location = get_object_or_404(Location, pk=pk)

    if request.method == 'POST':
        try:
            location.delete()
            messages.success(request, _(u'%s deleted') % location.title)
        except Exception as e:
            messages.error(request, e)

        return redirect(locations)

    title = _(u'Really delete this location?')
    explanation = _(u'This will not delete the orders at this location')

    return render(request, 'generic/delete.html', locals()) 

def delete_user(request, user_id):
    user = get_object_or_404(User, pk=user_id)

    if request.method == "POST":
        if user == request.user:
            messages.error(request, _('Deleting yourself is not allowed'))
            return redirect(list_users)
        try:
            user.delete()
            messages.success(request, _("User deleted"))
        except Exception as e:
            messages.error(request, e)

        return redirect(list_users)

    return render(request, "admin/users/remove.html", locals()) 

def import_repair(request, order_pk, device_pk):
    from servo.models import Device
    order = get_object_or_404(Order, pk=order_pk)
    device = get_object_or_404(Device, pk=device_pk)

    action = request.path
    form = ImportForm()

    if request.method == 'POST':
        form = ImportForm(request.POST)
        if form.is_valid():
            confirmation = form.cleaned_data['confirmation']
            try:
                repair = Repair.create_from_gsx(confirmation,
                                                order,
                                                device,
                                                request.user)
                messages.success(request, _('GSX repair %s imported successfully' % confirmation))
                return redirect(repair)
            except Exception as e:
                messages.error(request, e)
                return redirect(order)

    return render(request, "repairs/import_repair.html", locals()) 

def add_part(request, repair, part):
    """
    Adds this part to this GSX repair
    """
    rep = get_object_or_404(Repair, pk=repair)
    soi = rep.order.serviceorderitem_set.get(pk=part)

    if request.method == "POST":
        try:
            part = rep.add_part(soi, request.user)
            data = {'part': part.part_number, 'repair': rep.confirmation}
            msg = _("Part %(part)s added to repair %(repair)s") % data
            messages.success(request, msg)
        except gsxws.GsxError, e:
            messages.error(request, e)

        return redirect(rep.order) 

def remove_part(request, repair, part):
    rep = get_object_or_404(Repair, pk=repair)
    part = get_object_or_404(ServicePart, pk=part)

    if request.method == "POST":

        rep.connect_gsx(request.user)
        gsx_rep = rep.get_gsx_repair()
        orderline = part.get_repair_order_line()
        orderline.toDelete = True
        orderline.orderLineNumber = part.line_number

        try:
            gsx_rep.update({'orderLines': [orderline]})
            data = {'part': part.code, 'repair': rep.confirmation}
            msg = _(u"Part %(part)s removed from %(repair)s") % data
            messages.success(request, msg)
        except gsxws.GsxError, e:
            messages.error(request, e)

        return redirect(rep.order) 

def delete_repair(request, pk):
    """Delete this unsubmitted GSX repair."""
    repair = get_object_or_404(Repair, pk=pk)

    if repair.is_submitted():
        messages.error(request, _('Submitted repairs cannot be deleted'))
        return redirect(repair.order)

    if request.method == 'POST':
        order = repair.order
        repair.delete()
        messages.success(request, _('GSX repair deleted'))
        return redirect(order)

    context = {'action': request.path}
    return render(request, 'repairs/delete_repair.html', context) 

def list_incoming(request, shipment=None, status=""):
    """
    Lists purchase order items that have not arrived yet
    """
    data = prep_list_view(request)

    if request.POST.getlist("id"):
        count = len(request.POST.getlist("id"))
        for i in request.POST.getlist("id"):
            item = PurchaseOrderItem.objects.get(pk=i)
            try:
                item.receive(request.user)
            except ValueError as e:
                messages.error(request, e)
                return redirect(list_incoming)

        messages.success(request, _("%d products received") % count)

        return redirect(list_incoming)

    return render(request, "shipments/list_incoming.html", data) 

def delete_queue(request, pk=None):
    queue = get_object_or_404(Queue, pk=pk)

    if request.method == 'POST':
        try:
            queue.delete()
            messages.success(request, _("Queue deleted"))
        except Queue.ProtectedError:
            messages.error(request, _("Cannot delete queue"))

        return redirect(queues)

    return render(request, 'admin/queues/remove.html', locals())