Python utils.system_error函数代码示例

def error(request):
    log.info('Bango error: %s' % request.GET)

    # We should NOT have OK's coming from Bango, presumably.
    if request.GET.get('ResponseCode') == 'OK':
        log.error('in error(): Invalid Bango response code: {code}'
                  .format(code=request.GET.get('ResponseCode')))
        return system_error(request, code=msg.BAD_BANGO_CODE)

    result = _record(request)
    if result is not RECORDED_OK:
        return system_error(request, code=result)

    if request.GET.get('ResponseCode') == 'CANCEL':
        return render(request, 'bango/cancel.html',
                      {'error_code': msg.USER_CANCELLED})

    if request.GET.get('ResponseCode') == 'NOT_SUPPORTED':
        # This is a credit card or price point / region mismatch.
        # In theory users should never trigger this.
        return system_error(request, code=msg.UNSUPPORTED_PAY)

    log.error('Fatal Bango error: {code}; query string: {qs}'
              .format(code=request.GET.get('ResponseCode'),
                      qs=request.GET))
    return system_error(request, code=msg.BANGO_ERROR)

def success(request):
    """
    Process a redirect request after the Bango payment has completed.
    This URL endpoint is pre-arranged with Bango via the Billing Config API.

    Example request:

    ?ResponseCode=OK&ResponseMessage=Success&BangoUserId=1473894939
    &MerchantTransactionId=webpay%3a14d6a53c-fc4c-4bd1-8dc0-9f24646064b8
    &BangoTransactionId=1078692145
    &TransactionMethods=USA_TMOBILE%2cT-Mobile+USA%2cTESTPAY%2cTest+Pay
    &BillingConfigurationId=218240
    &MozSignature=
    c2cf7b937720c6e41f8b6401696cf7aef56975ebe54f8cee51eff4eb317841af
    &Currency=USD&Network=USA_TMOBILE&Price=0.99&P=
    """
    log.info('Bango success: %s' % request.GET)

    # We should only have OK's coming from Bango, presumably.
    if request.GET.get('ResponseCode') != 'OK':
        log.error('in success(): Invalid Bango response code: {code}'
                  .format(code=request.GET.get('ResponseCode')))
        return system_error(request, code=msg.BAD_BANGO_CODE)

    result = _record(request)
    if result is not RECORDED_OK:
        return system_error(request, code=result)

    # Signature verification was successful; fulfill the payment.
    tasks.payment_notify.delay(request.GET.get('MerchantTransactionId'))
    return render(request, 'bango/success.html')

def configure_transaction(request, data=None):
    """
    Configures a transaction so the user can be redirected to a buy screen.

    This is called from the client so that it can provide
    MCC/MNC at the same time.

    * When configure_transaction fails this will return a 400
      TRANS_CONFIG_FAILED

    """

    form = NetCodeForm(data or request.POST)

    mcc = None
    mnc = None
    if form.is_valid():
        mcc = form.cleaned_data['mcc']
        mnc = form.cleaned_data['mnc']
        log.info('Client detected network: mcc={mcc}, mnc={mnc}'
                 .format(mcc=mcc, mnc=mnc))
    else:
        log.info('Network form was invalid, no codes were applied.')
        log.debug('Network form errors: {e}'.format(e=form.errors.as_text()))

    if settings.SIMULATED_NETWORK:
        mcc = settings.SIMULATED_NETWORK['mcc']
        mnc = settings.SIMULATED_NETWORK['mnc']
        log.warning('OVERRIDING detected network with: mcc={mcc}, mnc={mnc}'
                    .format(mcc=mcc, mnc=mnc))

    is_simulation = request.session.get('is_simulation', False)
    pay_req = request.session.get('notes', {}).get('pay_request')
    payment_required = (
        pay_req['request']['pricePoint'] != '0' if pay_req else True)

    if payment_required:
        was_configured, error_code = tasks.configure_transaction(
            request, mcc=mcc, mnc=mnc)
        if not was_configured and not is_simulation:
            if not error_code:
                error_code = msg.TRANS_CONFIG_FAILED
            log.error('Configuring transaction failed: {er}'
                      .format(er=error_code))
            return system_error(request, code=error_code)
    else:
        solitude_buyer_uuid = request.session['uuid']
        log.info('Notifying for free in-app trans_id={t}; with '
                 'solitude_buyer_uuid={u}'.format(
                     t=request.session['trans_id'], u=solitude_buyer_uuid))
        tasks.free_notify.delay(request.session['notes'], solitude_buyer_uuid)

    sim = pay_req['request']['simulate'] if is_simulation else None
    client_trans_id = 'client-trans:{u}'.format(u=uuid.uuid4())
    log.info('Assigned client trans ID {client_trans} to trans ID {trans}'
             .format(trans=request.session['trans_id'],
                     client_trans=client_trans_id))
    return {'status': 'ok', 'simulation': sim,
            'client_trans_id': client_trans_id,
            'payment_required': payment_required}

def super_simulate(request):
    if not settings.ALLOW_ADMIN_SIMULATIONS:
        return http.HttpResponseForbidden()

    form = SuperSimulateForm(request.POST or None)
    if request.method == 'POST' and form.is_valid():

        if form.cleaned_data['action'] == 'real':
            if form.cleaned_data['network']:
                mcc, mnc = form.cleaned_data['network']
                was_configured, error_code = reconfigure_transaction(
                    request, mcc, mnc)
                if not was_configured:
                    if not error_code:
                        error_code = msg.TRANS_CONFIG_FAILED
                    log.error('Re-configuring transaction failed: {er}'
                              .format(er=error_code))
                    return system_error(request, code=error_code)

            # Continue to the wait screen.
            return redirect(reverse('pay.wait_to_start'))

        elif form.cleaned_data['action'] == 'simulate':
            send_simulated_notification(request.session['trans_id'])
            return render(request, 'pay/simulate_done.html', {})

        else:
            raise ValueError('Not sure what to do for action {a}'
                             .format(a=form.cleaned_data['action']))

    return render(request, 'pay/super_simulate.html', {'form': form})

def configure_transaction(request):
    """Configures the transaction to save time later.

    This is called from the client so that it can provide
    MCC/MNC at the same time.

    * When configure_transaction fails this will return a 400
      TRANS_CONFIG_FAILED

    """

    form = NetCodeForm(request.POST)
    sess = request.session

    if form.is_valid():
        mcc = form.cleaned_data['mcc']
        mnc = form.cleaned_data['mnc']
        notes = sess.get('notes', {})
        notes['network'] = {'mnc': mnc, 'mcc': mcc}
        sess['notes'] = notes
        log.info('Added mcc/mnc to session: '
                 '{network}'.format(network=notes['network']))

    log.info('configuring transaction {0} from client'
             .format(sess.get('trans_id')))

    if not tasks.configure_transaction(request):
        log.error('Configuring transaction failed.')
        return system_error(request, code=msg.TRANS_CONFIG_FAILED)
    else:
        return {'status': 'ok'}

def lobby(request):
    sess = request.session
    trans = None
    have_jwt = bool(request.GET.get('req'))

    log.info('starting from JWT? {have_jwt}'.format(have_jwt=have_jwt))
    if have_jwt:
        # If it returns a response there was likely
        # an error and we should return it.
        res = process_pay_req(request)
        if isinstance(res, http.HttpResponse):
            return res
    elif settings.TEST_PIN_UI:
        # This won't get you very far but it lets you create/enter PINs
        # and stops a traceback after that.
        sess['trans_id'] = trans_id()
    elif not sess.get('is_simulation', False):
        try:
            trans = solitude.get_transaction(sess.get('trans_id'))
        except (ObjectDoesNotExist, HttpClientError), exc:
            if sess.get('trans_id'):
                log.info('Attempted to restart non-existent transaction '
                         '{trans}; exc={exc}'
                         .format(trans=sess.get('trans_id'), exc=exc))
            return system_error(request, code=msg.BAD_REQUEST)

        log.info('Re-used existing transaction ID: {tx}'
                 .format(tx=sess.get('trans_id')))

def was_locked(request):
    try:
        client.unset_was_locked(uuid=get_user(request))
    except ResourceModified:
        return system_error(request, code=msg.RESOURCE_MODIFIED)
    request.session['uuid_pin_was_locked'] = False
    return render(request, 'pin/pin_was_locked.html')

def reset_cancel(request):
    try:
        client.set_needs_pin_reset(get_user(request), False)
    except ResourceModified:
        return system_error(request, code=msg.RESOURCE_MODIFIED)
    request.session['uuid_needs_pin_reset'] = False
    return http.HttpResponseRedirect(reverse('pin.verify'))

def create(request):
    form = forms.CreatePinForm()
    if request.method == 'POST':
        form = forms.CreatePinForm(uuid=get_user(request), data=request.POST)
        if form.is_valid():
            if getattr(form, 'buyer_exists', False):
                try:
                    res = client.change_pin(form.uuid,
                                            form.cleaned_data['pin'],
                                            etag=form.buyer_etag)
                except ResourceModified:
                    return system_error(request, code=msg.RESOURCE_MODIFIED)
            else:
                res = client.create_buyer(form.uuid, form.cleaned_data['pin'])
            if form.handle_client_errors(res):
                set_user_has_pin(request, True)
                return http.HttpResponseRedirect(reverse('pin.confirm'))
    form.no_pin = True
    return render(request, 'pin/pin_form.html', {'form': form,
                  'title': _('Create a Pin'),
                  'action': reverse('pin.create'),
                  'pin_form_tracking' : {
                      'pin_error_codes': form.pin_error_codes,
                  },
                  'track_cancel': {
                      'action': 'pin cancel',
                      'label': 'Create Pin Page',
                  }})

def configure_transaction(request):
    """
    Configures a transaction so the user can be redirected to a buy screen.

    This is called from the client so that it can provide
    MCC/MNC at the same time.

    * When configure_transaction fails this will return a 400
      TRANS_CONFIG_FAILED

    """

    form = NetCodeForm(request.POST)

    mcc = None
    mnc = None
    if form.is_valid():
        mcc = form.cleaned_data['mcc']
        mnc = form.cleaned_data['mnc']
        log.info('Client detected network: mcc={mcc}, mnc={mnc}'
                 .format(mcc=mcc, mnc=mnc))

    if settings.SIMULATED_NETWORK:
        mcc = settings.SIMULATED_NETWORK['mcc']
        mnc = settings.SIMULATED_NETWORK['mnc']
        log.warning('OVERRIDING detected network with: mcc={mcc}, mnc={mnc}'
                    .format(mcc=mcc, mnc=mnc))

    if not tasks.configure_transaction(request, mcc=mcc, mnc=mnc):
        log.error('Configuring transaction failed.')
        return system_error(request, code=msg.TRANS_CONFIG_FAILED)
    else:
        return {'status': 'ok'}

def error(request, provider):
    if provider != 'reference':
        raise NotImplementedError(
                'only the reference provider is implemented so far')

    notice = NoticeClasses[provider](request)
    try:
        notice.prepare()
    except msg.DevMessage as m:
        return system_error(request, code=m.code)

    # TODO: handle user cancellation, bug 957774.

    log.error('Fatal payment error for {provider}: {code}; query string: {qs}'
              .format(provider=provider, code=request.GET.get('ResponseCode'),
                      qs=request.GET))
    return system_error(request, code=msg.EXT_ERROR)

def lobby(request):
    sess = request.session
    have_jwt = bool(request.GET.get('req'))

    log.info('starting from JWT? {have_jwt}'.format(have_jwt=have_jwt))
    if have_jwt:
        # If it returns a response there was likely
        # an error and we should return it.
        res = process_pay_req(request)
        if isinstance(res, http.HttpResponse):
            return res
    elif settings.TEST_PIN_UI:
        # This won't get you very far but it lets you create/enter PINs
        # and stops a traceback after that.
        sess['trans_id'] = trans_id()

    pin_form = VerifyPinForm()

    if sess.get('uuid'):
        auth_utils.update_session(request,
                                  sess.get('uuid'),
                                  False,
                                  request.session.get('logged_in_user', None))

        redirect_url = check_pin_status(request)
        if redirect_url is not None:
            return http.HttpResponseRedirect(
                '{0}?next={1}'.format(reverse('pay.bounce'), redirect_url)
            )

    # If the buyer closed the trusted UI during reset flow, we want to unset
    # the reset pin flag. They can hit the forgot pin button if they still
    # don't remember their pin.
    if sess.get('uuid_needs_pin_reset'):
        try:
            solitude.set_needs_pin_reset(sess['uuid'], False)
        except ResourceModified:
            return system_error(request, code=msg.RESOURCE_MODIFIED)
        sess['uuid_needs_pin_reset'] = False

    if sess.get('is_simulation', False):
        sim_req = sess['notes']['pay_request']['request']['simulate']
        log.info('Starting simulate %s for %s'
                 % (sim_req, sess['notes']['issuer_key']))
        return render(request, 'pay/simulate.html', {
            'simulate': sim_req
        })

    return render(request, 'pay/lobby.html', {
        'action': reverse('pin.verify'),
        'form': pin_form,
        'title': _('Enter Pin'),
        'track_cancel': {
            'action': 'pin cancel',
            'label': 'Pin Entry Page',
        },
    })

def error(request, provider_name):
    provider = ProviderHelper(provider_name)
    if provider.name != 'reference':
        raise NotImplementedError(
            'only the reference provider is implemented so far')

    try:
        provider.prepare_notice(request)
    except msg.DevMessage as m:
        return system_error(request, code=m.code)

    # TODO: handle user cancellation, bug 957774.

    log.error('Fatal payment error for {provider}: {code}; query string: {qs}'
              .format(provider=provider.name,
                      code=request.GET.get('ResponseCode'),
                      qs=request.GET))
    return system_error(request, code=msg.EXT_ERROR)

def success(request, provider):
    if provider != 'reference':
        raise NotImplementedError(
                'only the reference provider is implemented so far')

    notice = NoticeClasses[provider](request)
    try:
        notice.prepare()
    except msg.DevMessage as m:
        return system_error(request, code=m.code)

    tasks.payment_notify.delay(notice.transaction_id)
    return render(request, 'provider/success.html')

def success(request, provider_name):
    provider = ProviderHelper(provider_name)
    if provider.name != 'reference':
        raise NotImplementedError(
            'only the reference provider is implemented so far')

    try:
        transaction_id = provider.prepare_notice(request)
    except msg.DevMessage as m:
        return system_error(request, code=m.code)

    tasks.payment_notify.delay(transaction_id)
    return render(request, 'provider/success.html')