View function which sends confirmation instructions.
502554
def send_confirmation():
    """"""

    form_class = _security.send_confirmation_form

    if request.is_json:
        form = form_class(MultiDict(request.get_json()))
    else:
        form = form_class()

    if form.validate_on_submit():
        send_confirmation_instructions(form.user)
        if not request.is_json:
            do_flash(*get_message('CONFIRMATION_REQUEST',
                     email=form.user.email))

    if request.is_json:
        return _render_json(form)

    return _security.render_template(
        config_value('SEND_CONFIRMATION_TEMPLATE'),
        send_confirmation_form=form,
        **_ctx('send_confirmation')
    )
896594
function handleNotificationThatWalletFullyApproved(wallet, device_address, onDone){
	db.query( // just in case it was not inserted yet
		"INSERT "+db.getIgnore()+" INTO extended_pubkeys (wallet, device_address) VALUES(?,?)",
		[wallet, device_address],
		function(){
			db.query(
				"UPDATE extended_pubkeys SET member_ready_date="+db.getNow()+" WHERE wallet=? AND device_address=?", 
				[wallet, device_address],
				function(){
					checkAndFinalizeWallet(wallet, onDone);
				}
			);
		}
	);
}
456578
def _status_message_received(self, msg):
        
        if not self._status_received:
            asyncio.ensure_future(self._confirm_status_received(),
                                  loop=self._loop)
575165
public static Optional<ButtonType> showConfirmation(String title, String header, String content) {
        return alert(title, header, content, AlertType.CONFIRMATION);
    }
668716
def confirm_action?(message)
      require 'highline/import'
      quest message
      response =  ask(highline_quest('(y/n)')) do |q|
        q.default = "n"
      end
      return response == 'y' ? true : false
    end
1121065
def update_confirmation_item(self, confirmation_item_id, confirmation_item_dict):
        
        return self._create_put_request(
            resource=CONFIRMATION_ITEMS,
            billomat_id=confirmation_item_id,
            send_data=confirmation_item_dict
        )
489402
def confirm_reservation(reservation_key: '', payment_method: '', amount_paid: nil)

      # step 1: confirm
      path = "reservation/#{reservation_key}/confirm"
      body = {
        PaymentMethod: payment_method,
        AmountPaid: amount_paid
      }
      call(path, http_method: :post, body: body.to_json)

      # step 2: get tickets
      # GET /api/v1/reservation/{reservationKey}/tickets
      path = "reservation/#{reservation_key}/tickets"
      result = call(path, http_method: :get)

      # define new list
      list = []

      for ticket in result
        list << ShakeTheCounter::Ticket.new(ticket)
      end
      return list
    end
1373805
def update_confirmation(self, confirmation_id, confirmation_dict):
        
        return self._create_put_request(
            resource=CONFIRMATIONS,
            billomat_id=confirmation_id,
            send_data=confirmation_dict
        )
332263
function(title, message, cb, okText) {
    cb = cb || function() {};
    title = title || '';
    okText = okText || gettextCatalog.getString('OK');
    $window.top.navigator.notification.alert(message, cb, title, okText);
  }
1128008
def confirm(message='Confirm (y or n) '):
    
    assert isinstance(message, text_type)

    app = create_confirm_application(message)
    return run_application(app)
1019217
def confirm(text='', title='', buttons=[OK_TEXT, CANCEL_TEXT], root=None, timeout=None):
    """"""
    assert TKINTER_IMPORT_SUCCEEDED, 'Tkinter is required for pymsgbox'
    return _buttonbox(msg=text, title=title, choices=[str(b) for b in buttons], root=root, timeout=timeout)
34862
def notify_complete(self, result_code, error_info):
        
        if not isinstance(result_code, baseinteger):
            raise TypeError("result_code can only be an instance of type baseinteger")
        if not isinstance(error_info, IVirtualBoxErrorInfo):
            raise TypeError("error_info can only be an instance of type IVirtualBoxErrorInfo")
        self._call("notifyComplete",
                     in_p=[result_code, error_info])
313656
function (showSignal) {
        return function (msg) {
            var b = new Buffer(1);
            b.writeUInt8(showSignal ? 1 : 0, 0);

            msg.addOption(new Option(Message.Option.URI_PATH, new Buffer("s")));
            msg.addOption(new Option(Message.Option.URI_QUERY, b));
            return msg;
        };
    }
494608
def on_message(self, message_protocol_entity):
        
        logger.info("Message id %s received" % message_protocol_entity.getId())
        # answer with receipt
        self.toLower(message_protocol_entity.ack())
790519
function cmd_confirm(args, done) {
    var seneca = this
    var why
    var userent = seneca.make(user_canon)

    userent.load$({ confirmcode: args.code }, function(err, user) {
      if (err) return done(err)

      if (user) {
        if (user.active) {
          user.confirmed = true
          user.save$(function(err, user) {
            if (err) return done(err)
            done(null, { ok: true, user: user })
          })
        } else {
          seneca.log.debug(
            'confirm/fail',
            (why = 'not-active'),
            args.code,
            user
          )
          return done(null, { ok: false, why: why, user: user })
        }
      } else {
        seneca.log.debug(
          'confirm/fail',
          (why = 'invalid-code'),
          args.code,
          user
        )
        return done(null, { ok: false, why: why })
      }
    })
  }
1169486
def send_notification(self, method, args, kwargs):
        """"""
        msg = dumps([1, method, args, kwargs])
        self.send(msg)
944629
function confirm(args, callback)
{
	var cstate;

	mod_assertplus.object(args, 'args');
	mod_assertplus.string(args.message, 'args.message');

	/*
	 * This object encapsulates the state of this asynchronous operation.
	 */
	cstate = {
	    /* prompt message */
	    'cf_message': args.message,

	    /* streams used for output and input */
	    'cf_outstream': process.stdout,
	    'cf_instream': process.stdin,

	    /* input is a tty */
	    'cf_intty': null,
	    'cf_inraw': null,

	    /* data read from input */
	    'cf_read': null,

	    /* user callback to be invoked */
	    'cf_callback': callback
	};

	cstate.cf_intty = cstate.cf_instream.isTTY;
	if (cstate.cf_intty) {
		cstate.cf_inraw = cstate.cf_instream.isRaw;
		if (!cstate.cf_inraw) {
			cstate.cf_instream.setRawMode(true);
		}
	}

	cstate.cf_outstream.write(cstate.cf_message);
	cstate.cf_read = cstate.cf_instream.read(1);
	if (cstate.cf_read === null) {
		cstate.cf_instream.once('readable', function () {
			cstate.cf_read = cstate.cf_instream.read(1);
			confirmFini(cstate);
		});
	} else {
		setImmediate(confirmFini, cstate);
	}
}