def get(self, request, *args, **kwargs): u = request.GET.get('query', '') if len(u) < 2: return JsonResponse({'results': []}) if "-" in u: code = (Q(event__slug__icontains=u.split("-")[0]) & Q(code__icontains=Order.normalize_code(u.split("-")[1]))) else: code = Q(code__icontains=Order.normalize_code(u)) qs = self.order_qs().order_by('pk').annotate( inr=Concat('invoices__prefix', 'invoices__invoice_no')).filter( code | Q(email__icontains=u) | Q(all_positions__attendee_name_cached__icontains=u) | Q(all_positions__attendee_email__icontains=u) | Q(invoice_address__name_cached__icontains=u) | Q(invoice_address__company__icontains=u) | Q(invoices__invoice_no=u) | Q(invoices__invoice_no=u.zfill(5)) | Q(inr=u)).select_related('event').annotate( pcnt=Count('invoices')).distinct() # Yep, we wouldn't need to count the invoices here. However, having this Count() statement in there # tricks Django into generating a GROUP BY clause that it otherwise wouldn't and that is required to # avoid duplicate results. Yay? return JsonResponse({ 'results': [{ 'code': o.event.slug.upper() + '-' + o.code, 'status': o.get_status_display(), 'total': money_filter(o.total, o.event.currency) } for o in qs] })
def get_queryset(self): qs = Order.objects.all() if not self.request.user.is_superuser: qs = qs.filter( Q(event__organizer_id__in=self.request.user.teams.filter( all_events=True, can_view_orders=True).values_list('organizer', flat=True)) | Q(event_id__in=self.request.user.teams.filter( can_view_orders=True).values_list('limit_events__id', flat=True)) ) if self.request.GET.get("query", "") != "": u = self.request.GET.get("query", "") if "-" in u: code = (Q(event__slug__icontains=u.split("-")[0]) & Q(code__icontains=Order.normalize_code(u.split("-")[1]))) else: code = Q(code__icontains=Order.normalize_code(u)) qs = qs.filter( code | Q(email__icontains=u) | Q(positions__attendee_name__icontains=u) | Q(positions__attendee_email__icontains=u) | Q(invoice_address__name__icontains=u) | Q(invoice_address__company__icontains=u) ) print(qs.query) if self.request.GET.get("ordering", "") != "": p = self.request.GET.get("ordering", "") p_admissable = ('event', '-event', '-code', 'code', '-email', 'email', '-total', 'total', '-datetime', 'datetime', '-status', 'status') if p in p_admissable: qs = qs.order_by(p) return qs.distinct().prefetch_related('event', 'event__organizer')
def filter_qs(self, qs): fdata = self.cleaned_data if fdata.get('query'): u = fdata.get('query') if "-" in u: code = (Q(event__slug__icontains=u.rsplit("-", 1)[0]) & Q(code__icontains=Order.normalize_code(u.rsplit("-", 1)[1]))) else: code = Q(code__icontains=Order.normalize_code(u)) matching_invoices = Invoice.objects.filter( Q(invoice_no__iexact=u) | Q(invoice_no__iexact=u.zfill(5)) | Q(full_invoice_no__iexact=u) ).values_list('order_id', flat=True) matching_positions = OrderPosition.objects.filter( Q(order=OuterRef('pk')) & Q( Q(attendee_name_cached__icontains=u) | Q(attendee_email__icontains=u) | Q(secret__istartswith=u) ) ).values('id') qs = qs.annotate(has_pos=Exists(matching_positions)).filter( code | Q(email__icontains=u) | Q(invoice_address__name_cached__icontains=u) | Q(invoice_address__company__icontains=u) | Q(pk__in=matching_invoices) | Q(comment__icontains=u) | Q(has_pos=True) ) if fdata.get('status'): s = fdata.get('status') if s == 'o': qs = qs.filter(status=Order.STATUS_PENDING, expires__lt=now().replace(hour=0, minute=0, second=0)) elif s == 'np': qs = qs.filter(status__in=[Order.STATUS_PENDING, Order.STATUS_PAID]) elif s == 'ne': qs = qs.filter(status__in=[Order.STATUS_PENDING, Order.STATUS_EXPIRED]) elif s in ('p', 'n', 'e', 'c', 'r'): qs = qs.filter(status=s) if fdata.get('ordering'): qs = qs.order_by(self.get_order_by()) if fdata.get('provider'): qs = qs.annotate( has_payment_with_provider=Exists( OrderPayment.objects.filter( Q(order=OuterRef('pk')) & Q(provider=fdata.get('provider')) ) ) ) qs = qs.filter(has_payment_with_provider=1) return qs
def get(self, request, *args, **kwargs): u = request.GET.get('query', '') if len(u) < 2: return JsonResponse({'results': []}) if "-" in u: code = (Q(event__slug__icontains=u.split("-")[0]) & Q(code__icontains=Order.normalize_code(u.split("-")[1]))) else: code = Q(code__icontains=Order.normalize_code(u)) qs = self.order_qs().order_by('pk').annotate(inr=Concat('invoices__prefix', 'invoices__invoice_no')).filter( code | Q(email__icontains=u) | Q(positions__attendee_name_cached__icontains=u) | Q(positions__attendee_email__icontains=u) | Q(invoice_address__name_cached__icontains=u) | Q(invoice_address__company__icontains=u) | Q(invoices__invoice_no=u) | Q(invoices__invoice_no=u.zfill(5)) | Q(inr=u) ).select_related('event').annotate(pcnt=Count('invoices')).distinct() # Yep, we wouldn't need to count the invoices here. However, having this Count() statement in there # tricks Django into generating a GROUP BY clause that it otherwise wouldn't and that is required to # avoid duplicate results. Yay? return JsonResponse({ 'results': [ { 'code': o.event.slug.upper() + '-' + o.code, 'status': o.get_status_display(), 'total': money_filter(o.total, o.event.currency) } for o in qs ] })
def filter_qs(self, qs): fdata = self.cleaned_data if fdata.get('query'): u = fdata.get('query') if "-" in u: code = ( Q(event__slug__icontains=u.split("-")[0]) & Q(code__icontains=Order.normalize_code(u.split("-")[1]))) else: code = Q(code__icontains=Order.normalize_code(u)) qs = qs.filter(code | Q(email__icontains=u) | Q(positions__attendee_name__icontains=u) | Q(positions__attendee_email__icontains=u) | Q(invoice_address__name__icontains=u) | Q(invoice_address__company__icontains=u)) if fdata.get('status'): s = fdata.get('status') if s == 'o': qs = qs.filter(status=Order.STATUS_PENDING, expires__lt=now().replace(hour=0, minute=0, second=0)) elif s == 'ne': qs = qs.filter( status__in=[Order.STATUS_PENDING, Order.STATUS_EXPIRED]) else: qs = qs.filter(status=s) return qs
def _find_order_for_code(base_qs, code): try_codes = [ code, Order.normalize_code(code, is_fallback=True), code[:settings.ENTROPY['order_code']], Order.normalize_code(code[:settings.ENTROPY['order_code']], is_fallback=True) ] for c in try_codes: try: return base_qs.get(code=c) except Order.DoesNotExist: pass
def filter_qs(self, qs): fdata = self.cleaned_data if fdata.get('query'): u = fdata.get('query') if "-" in u: code = (Q(event__slug__icontains=u.split("-")[0]) & Q(code__icontains=Order.normalize_code(u.split("-")[1]))) else: code = Q(code__icontains=Order.normalize_code(u)) matching_invoice = Invoice.objects.filter( order=OuterRef('pk'), ).annotate( inr=Concat('prefix', 'invoice_no') ).filter( Q(invoice_no__iexact=u) | Q(invoice_no__iexact=u.zfill(5)) | Q(inr=u) ) qs = qs.annotate(has_inv=Exists(matching_invoice)) qs = qs.filter( code | Q(email__icontains=u) | Q(positions__attendee_name__icontains=u) | Q(positions__attendee_email__icontains=u) | Q(invoice_address__name__icontains=u) | Q(invoice_address__company__icontains=u) | Q(has_inv=True) ) if fdata.get('status'): s = fdata.get('status') if s == 'o': qs = qs.filter(status=Order.STATUS_PENDING, expires__lt=now().replace(hour=0, minute=0, second=0)) elif s == 'ne': qs = qs.filter(status__in=[Order.STATUS_PENDING, Order.STATUS_EXPIRED]) else: qs = qs.filter(status=s) if fdata.get('ordering'): qs = qs.order_by(dict(self.fields['ordering'].choices)[fdata.get('ordering')]) if fdata.get('provider'): qs = qs.filter(payment_provider=fdata.get('provider')) return qs
def get(self, request, *args, **kwargs): query = request.GET.get('query', '') if len(query) < 2: return JsonResponse({'results': []}) qs = self.request.event.orders.filter( Q(code__icontains=query) | Q(code__icontains=Order.normalize_code(query))) return JsonResponse({ 'results': [{ 'code': o.code, 'status': o.get_status_display(), 'total': lformat("%.2f", o.total) + ' ' + self.request.event.currency } for o in qs] })
def get(self, request, *args, **kwargs): from django.utils.formats import localize query = request.GET.get('query', '') if len(query) < 2: return JsonResponse({'results': []}) qs = self.order_qs().filter( Q(code__icontains=query) | Q(code__icontains=Order.normalize_code(query))).select_related( 'event') return JsonResponse({ 'results': [{ 'code': o.event.slug.upper() + '-' + o.code, 'status': o.get_status_display(), 'total': localize(o.total) + ' ' + o.event.currency } for o in qs] })
def _handle_transaction(event: Event, trans: BankTransaction, code: str): try: trans.order = event.orders.get(code=code) except Order.DoesNotExist: normalized_code = Order.normalize_code(code) try: trans.order = event.orders.get(code=normalized_code) except Order.DoesNotExist: trans.state = BankTransaction.STATE_NOMATCH trans.save() return if trans.order.status == Order.STATUS_PAID: trans.state = BankTransaction.STATE_DUPLICATE elif trans.order.status == Order.STATUS_REFUNDED: trans.state = BankTransaction.STATE_ERROR trans.message = ugettext_noop('The order has already been refunded.') elif trans.order.status == Order.STATUS_CANCELED: trans.state = BankTransaction.STATE_ERROR trans.message = ugettext_noop('The order has already been canceled.') elif trans.amount != trans.order.total: trans.state = BankTransaction.STATE_INVALID trans.message = ugettext_noop('The transaction amount is incorrect.') else: try: mark_order_paid(trans.order, provider='banktransfer', info=json.dumps({ 'reference': trans.reference, 'date': trans.date, 'payer': trans.payer, 'trans_id': trans.pk })) except Quota.QuotaExceededException as e: trans.state = BankTransaction.STATE_ERROR trans.message = str(e) except SendMailException: trans.state = BankTransaction.STATE_ERROR trans.message = ugettext_noop('Problem sending email.') else: trans.state = BankTransaction.STATE_VALID trans.save()
def get(self, request, *args, **kwargs): query = request.GET.get('query', '') if len(query) < 2: return JsonResponse({'results': []}) qs = self.request.event.orders.filter(Q(code__icontains=query) | Q(code__icontains=Order.normalize_code(query))) return JsonResponse({ 'results': [ { 'code': o.code, 'status': o.get_status_display(), 'total': lformat("%.2f", o.total) + ' ' + self.request.event.currency } for o in qs ] })
def _handle_transaction(trans: BankTransaction, matches: tuple, event: Event = None, organizer: Organizer = None): orders = [] if event: for slug, code in matches: try: orders.append(event.orders.get(code=code)) except Order.DoesNotExist: normalized_code = Order.normalize_code(code, is_fallback=True) try: orders.append(event.orders.get(code=normalized_code)) except Order.DoesNotExist: pass else: qs = Order.objects.filter(event__organizer=organizer) for slug, code in matches: try: orders.append(qs.get(event__slug__iexact=slug, code=code)) except Order.DoesNotExist: normalized_code = Order.normalize_code(code, is_fallback=True) try: orders.append( qs.get(event__slug__iexact=slug, code=normalized_code)) except Order.DoesNotExist: pass if not orders: # No match trans.state = BankTransaction.STATE_NOMATCH trans.save() return else: trans.order = orders[0] for o in orders: if o.status == Order.STATUS_PAID and o.pending_sum <= Decimal('0.00'): trans.state = BankTransaction.STATE_DUPLICATE trans.save() return elif o.status == Order.STATUS_CANCELED: trans.state = BankTransaction.STATE_ERROR trans.message = gettext_noop( 'The order has already been canceled.') trans.save() return if len(orders) > 1: # Multi-match! Can we split this automatically? order_pending_sum = sum(o.pending_sum for o in orders) if order_pending_sum != trans.amount: # we can't :( this needs to be dealt with by a human trans.state = BankTransaction.STATE_NOMATCH trans.message = gettext_noop( 'Automatic split to multiple orders not possible.') trans.save() return # we can! splits = [(o, o.pending_sum) for o in orders] else: splits = [(orders[0], trans.amount)] trans.state = BankTransaction.STATE_VALID for order, amount in splits: try: p, created = order.payments.get_or_create( amount=amount, provider='banktransfer', state__in=(OrderPayment.PAYMENT_STATE_CREATED, OrderPayment.PAYMENT_STATE_PENDING), defaults={ 'state': OrderPayment.PAYMENT_STATE_CREATED, }) except OrderPayment.MultipleObjectsReturned: created = False p = order.payments.filter( amount=amount, provider='banktransfer', state__in=(OrderPayment.PAYMENT_STATE_CREATED, OrderPayment.PAYMENT_STATE_PENDING), ).last() p.info_data = { 'reference': trans.reference, 'date': trans.date_parsed.isoformat() if trans.date_parsed else trans.date, 'payer': trans.payer, 'iban': trans.iban, 'bic': trans.bic, 'full_amount': str(trans.amount), 'trans_id': trans.pk } if created: # We're perform a payment method switching on-demand here old_fee, new_fee, fee, p = change_payment_provider( order, p.payment_provider, p.amount, new_payment=p, create_log=False) # noqa if fee: p.fee = fee p.save(update_fields=['fee']) try: p.confirm() except Quota.QuotaExceededException: # payment confirmed but order status could not be set, no longer problem of this plugin cancel_old_payments(order) except SendMailException: # payment confirmed but order status could not be set, no longer problem of this plugin cancel_old_payments(order) else: cancel_old_payments(order) order.refresh_from_db() if order.pending_sum > Decimal( '0.00') and order.status == Order.STATUS_PENDING: notify_incomplete_payment(order) trans.save()
def get_order(self, code): try: return Order.objects.get(code=code, event=self.request.event) except Order.DoesNotExist: return Order.objects.get(code=Order.normalize_code(code), event=self.request.event)
def _handle_transaction(trans: BankTransaction, code: str, event: Event = None, organizer: Organizer = None, slug: str = None): if event: try: trans.order = event.orders.get(code=code) except Order.DoesNotExist: normalized_code = Order.normalize_code(code) try: trans.order = event.orders.get(code=normalized_code) except Order.DoesNotExist: trans.state = BankTransaction.STATE_NOMATCH trans.save() return else: qs = Order.objects.filter(event__organizer=organizer) if slug: qs = qs.filter(event__slug__iexact=slug) try: trans.order = qs.get(code=code) except Order.DoesNotExist: normalized_code = Order.normalize_code(code) try: trans.order = qs.get(code=normalized_code) except Order.DoesNotExist: trans.state = BankTransaction.STATE_NOMATCH trans.save() return if trans.order.status == Order.STATUS_PAID and trans.order.pending_sum <= Decimal( '0.00'): trans.state = BankTransaction.STATE_DUPLICATE elif trans.order.status == Order.STATUS_REFUNDED: trans.state = BankTransaction.STATE_ERROR trans.message = ugettext_noop('The order has already been refunded.') elif trans.order.status == Order.STATUS_CANCELED: trans.state = BankTransaction.STATE_ERROR trans.message = ugettext_noop('The order has already been canceled.') else: p = trans.order.payments.get_or_create( amount=trans.amount, provider='banktransfer', state__in=(OrderPayment.PAYMENT_STATE_CREATED, OrderPayment.PAYMENT_STATE_PENDING), defaults={ 'state': OrderPayment.PAYMENT_STATE_CREATED, })[0] p.info_data = { 'reference': trans.reference, 'date': trans.date, 'payer': trans.payer, 'trans_id': trans.pk } try: p.confirm() except Quota.QuotaExceededException: trans.state = BankTransaction.STATE_VALID trans.order.payments.filter( provider='banktransfer', state__in=(OrderPayment.PAYMENT_STATE_CREATED, OrderPayment.PAYMENT_STATE_PENDING), ).update(state=OrderPayment.PAYMENT_STATE_CANCELED) except SendMailException: trans.state = BankTransaction.STATE_VALID trans.order.payments.filter( provider='banktransfer', state__in=(OrderPayment.PAYMENT_STATE_CREATED, OrderPayment.PAYMENT_STATE_PENDING), ).update(state=OrderPayment.PAYMENT_STATE_CANCELED) else: trans.state = BankTransaction.STATE_VALID trans.order.payments.filter( provider='banktransfer', state__in=(OrderPayment.PAYMENT_STATE_CREATED, OrderPayment.PAYMENT_STATE_PENDING), ).update(state=OrderPayment.PAYMENT_STATE_CANCELED) trans.save()
def _handle_transaction(trans: BankTransaction, code: str, event: Event=None, organizer: Organizer=None, slug: str=None): if event: try: trans.order = event.orders.get(code=code) except Order.DoesNotExist: normalized_code = Order.normalize_code(code) try: trans.order = event.orders.get(code=normalized_code) except Order.DoesNotExist: trans.state = BankTransaction.STATE_NOMATCH trans.save() return else: qs = Order.objects.filter(event__organizer=organizer) if slug: qs = qs.filter(event__slug__iexact=slug) try: trans.order = qs.get(code=code) except Order.DoesNotExist: normalized_code = Order.normalize_code(code) try: trans.order = qs.get(code=normalized_code) except Order.DoesNotExist: trans.state = BankTransaction.STATE_NOMATCH trans.save() return if trans.order.status == Order.STATUS_PAID and trans.order.pending_sum <= Decimal('0.00'): trans.state = BankTransaction.STATE_DUPLICATE elif trans.order.status == Order.STATUS_CANCELED: trans.state = BankTransaction.STATE_ERROR trans.message = ugettext_noop('The order has already been canceled.') else: try: p, created = trans.order.payments.get_or_create( amount=trans.amount, provider='banktransfer', state__in=(OrderPayment.PAYMENT_STATE_CREATED, OrderPayment.PAYMENT_STATE_PENDING), defaults={ 'state': OrderPayment.PAYMENT_STATE_CREATED, } ) except OrderPayment.MultipleObjectsReturned: created = False p = trans.order.payments.filter( amount=trans.amount, provider='banktransfer', state__in=(OrderPayment.PAYMENT_STATE_CREATED, OrderPayment.PAYMENT_STATE_PENDING), ).last() p.info_data = { 'reference': trans.reference, 'date': trans.date, 'payer': trans.payer, 'trans_id': trans.pk } if created: # We're perform a payment method switchign on-demand here old_fee, new_fee, fee = change_payment_provider(trans.order, p.payment_provider, p.amount, new_payment=p) # noqa if fee: p.fee = fee p.save(update_fields=['fee']) try: p.confirm() except Quota.QuotaExceededException: trans.state = BankTransaction.STATE_VALID trans.order.payments.filter( provider='banktransfer', state__in=(OrderPayment.PAYMENT_STATE_CREATED, OrderPayment.PAYMENT_STATE_PENDING), ).update(state=OrderPayment.PAYMENT_STATE_CANCELED) except SendMailException: trans.state = BankTransaction.STATE_VALID trans.order.payments.filter( provider='banktransfer', state__in=(OrderPayment.PAYMENT_STATE_CREATED, OrderPayment.PAYMENT_STATE_PENDING), ).update(state=OrderPayment.PAYMENT_STATE_CANCELED) else: trans.state = BankTransaction.STATE_VALID trans.order.payments.filter( provider='banktransfer', state__in=(OrderPayment.PAYMENT_STATE_CREATED, OrderPayment.PAYMENT_STATE_PENDING), ).update(state=OrderPayment.PAYMENT_STATE_CANCELED) o = trans.order o.refresh_from_db() if o.pending_sum > Decimal('0.00') and o.status == Order.STATUS_PENDING: notify_incomplete_payment(o) trans.save()
def _handle_transaction(trans: BankTransaction, code: str, event: Event=None, organizer: Organizer=None, slug: str=None): if event: try: trans.order = event.orders.get(code=code) except Order.DoesNotExist: normalized_code = Order.normalize_code(code) try: trans.order = event.orders.get(code=normalized_code) except Order.DoesNotExist: trans.state = BankTransaction.STATE_NOMATCH trans.save() return else: qs = Order.objects.filter(event__organizer=organizer) if slug: qs = qs.filter(event__slug__iexact=slug) try: trans.order = qs.get(code=code) except Order.DoesNotExist: normalized_code = Order.normalize_code(code) try: trans.order = qs.get(code=normalized_code) except Order.DoesNotExist: trans.state = BankTransaction.STATE_NOMATCH trans.save() return if trans.order.status == Order.STATUS_PAID and trans.order.pending_sum <= Decimal('0.00'): trans.state = BankTransaction.STATE_DUPLICATE elif trans.order.status == Order.STATUS_REFUNDED: trans.state = BankTransaction.STATE_ERROR trans.message = ugettext_noop('The order has already been refunded.') elif trans.order.status == Order.STATUS_CANCELED: trans.state = BankTransaction.STATE_ERROR trans.message = ugettext_noop('The order has already been canceled.') else: p = trans.order.payments.get_or_create( amount=trans.amount, provider='banktransfer', state__in=(OrderPayment.PAYMENT_STATE_CREATED, OrderPayment.PAYMENT_STATE_PENDING), defaults={ 'state': OrderPayment.PAYMENT_STATE_CREATED, } )[0] p.info_data = { 'reference': trans.reference, 'date': trans.date, 'payer': trans.payer, 'trans_id': trans.pk } try: p.confirm() except Quota.QuotaExceededException: trans.state = BankTransaction.STATE_VALID trans.order.payments.filter( provider='banktransfer', state__in=(OrderPayment.PAYMENT_STATE_CREATED, OrderPayment.PAYMENT_STATE_PENDING), ).update(state=OrderPayment.PAYMENT_STATE_CANCELED) except SendMailException: trans.state = BankTransaction.STATE_VALID trans.order.payments.filter( provider='banktransfer', state__in=(OrderPayment.PAYMENT_STATE_CREATED, OrderPayment.PAYMENT_STATE_PENDING), ).update(state=OrderPayment.PAYMENT_STATE_CANCELED) else: trans.state = BankTransaction.STATE_VALID trans.order.payments.filter( provider='banktransfer', state__in=(OrderPayment.PAYMENT_STATE_CREATED, OrderPayment.PAYMENT_STATE_PENDING), ).update(state=OrderPayment.PAYMENT_STATE_CANCELED) trans.save()
def filter_qs(self, qs): fdata = self.cleaned_data if fdata.get('query'): u = fdata.get('query') if "-" in u: code = (Q(event__slug__icontains=u.rsplit("-", 1)[0]) & Q(code__icontains=Order.normalize_code(u.rsplit("-", 1)[1]))) else: code = Q(code__icontains=Order.normalize_code(u)) matching_invoices = Invoice.objects.filter( Q(invoice_no__iexact=u) | Q(invoice_no__iexact=u.zfill(5)) | Q(full_invoice_no__iexact=u) ).values_list('order_id', flat=True) matching_positions = OrderPosition.objects.filter( Q( Q(attendee_name_cached__icontains=u) | Q(attendee_email__icontains=u) | Q(secret__istartswith=u) | Q(pseudonymization_id__istartswith=u) ) ).values_list('order_id', flat=True) matching_invoice_addresses = InvoiceAddress.objects.filter( Q( Q(name_cached__icontains=u) | Q(company__icontains=u) ) ).values_list('order_id', flat=True) matching_orders = Order.objects.filter( code | Q(email__icontains=u) | Q(comment__icontains=u) ).values_list('id', flat=True) mainq = ( Q(pk__in=matching_orders) | Q(pk__in=matching_invoices) | Q(pk__in=matching_positions) | Q(pk__in=matching_invoice_addresses) | Q(pk__in=matching_invoices) ) for recv, q in order_search_filter_q.send(sender=getattr(self, 'event', None), query=u): mainq = mainq | q qs = qs.filter( mainq ) if fdata.get('status'): s = fdata.get('status') if s == 'o': qs = qs.filter(status=Order.STATUS_PENDING, expires__lt=now().replace(hour=0, minute=0, second=0)) elif s == 'np': qs = qs.filter(status__in=[Order.STATUS_PENDING, Order.STATUS_PAID]) elif s == 'ne': qs = qs.filter(status__in=[Order.STATUS_PENDING, Order.STATUS_EXPIRED]) elif s in ('p', 'n', 'e', 'c', 'r'): qs = qs.filter(status=s) elif s == 'overpaid': qs = Order.annotate_overpayments(qs, refunds=False, results=False, sums=True) qs = qs.filter( Q(~Q(status=Order.STATUS_CANCELED) & Q(pending_sum_t__lt=0)) | Q(Q(status=Order.STATUS_CANCELED) & Q(pending_sum_rc__lt=0)) ) elif s == 'rc': qs = qs.filter( cancellation_requests__isnull=False ) elif s == 'pendingpaid': qs = Order.annotate_overpayments(qs, refunds=False, results=False, sums=True) qs = qs.filter( Q(status__in=(Order.STATUS_EXPIRED, Order.STATUS_PENDING)) & Q(pending_sum_t__lte=0) & Q(require_approval=False) ) elif s == 'underpaid': qs = Order.annotate_overpayments(qs, refunds=False, results=False, sums=True) qs = qs.filter( status=Order.STATUS_PAID, pending_sum_t__gt=0 ) elif s == 'pa': qs = qs.filter( status=Order.STATUS_PENDING, require_approval=True ) elif s == 'testmode': qs = qs.filter( testmode=True ) elif s == 'cp': s = OrderPosition.objects.filter( order=OuterRef('pk') ) qs = qs.annotate( has_pc=Exists(s) ).filter( Q(status=Order.STATUS_PAID, has_pc=False) | Q(status=Order.STATUS_CANCELED) ) if fdata.get('ordering'): qs = qs.order_by(self.get_order_by()) if fdata.get('provider'): qs = qs.annotate( has_payment_with_provider=Exists( OrderPayment.objects.filter( Q(order=OuterRef('pk')) & Q(provider=fdata.get('provider')) ) ) ) qs = qs.filter(has_payment_with_provider=1) return qs