Request for notify.
359106
static void requestNotify(Source source) {
        Intent intent = new Intent(source.getContext(), BridgeActivity.class);
        intent.putExtra(KEY_TYPE, BridgeRequest.TYPE_NOTIFY);
        source.startActivity(intent);
    }
1223317
def send_notice(self, text):
        """"""
        return self.client.api.send_notice(self.room_id, text)
896218
def notify(self, method, params=None):
        
        log.debug('Sending notification: %s %s', method, params)

        message = {
            'jsonrpc': JSONRPC_VERSION,
            'method': method,
        }
        if params is not None:
            message['params'] = params

        self._consumer(message)
1050252
def notify(self):
        
        if flask.has_request_context():
            emit(_NAME + str(self._uuid))
        else:
            sio = flask.current_app.extensions['socketio']
            sio.emit(_NAME + str(self._uuid))
        eventlet.sleep()
424380
def notify_by(self, invoice_id, medium, **kwargs):
        "
        url = "{}/{}/notify_by/{}".format(self.base_url, invoice_id, medium)
        return self.post_url(url, {}, **kwargs)
1273333
def notify(contact_request)
      @contact_request = contact_request

      mail to: notification_recipients,
           from: notification_sender(contact_request),
           subject: notification_subject
    end
1152171
def notify(title,
           message,
           auth_token,
           source=None,
           url=None,
           url_title=None,
           image=None,
           ttl=None,
           important=False,
           silent=False,
           retcode=None):
    

    data = {
        'Title': title,
        'Body': message,
        'AuthorizationToken': auth_token,
    }

    if source:
        data['Source'] = source
    if url:
        data['Link'] = url
    if url and url_title:
        data['LinkTitle'] = url_title
    if image:
        data['Image'] = image
    if ttl:
        data['TimeToLive'] = int(ttl)
    if important:
        data['IsImportant'] = 'True'
    if silent:
        data['IsSilent'] = 'True'

    headers = {'User-Agent': USER_AGENT}
    response = requests.post(PUSHALOT_API_URL, data=data, headers=headers)
    response.raise_for_status()
344237
def _notify_remove_at(self, index, length=1):
        """"""
        slice_ = self._slice_at(index, length)
        self._notify_remove(slice_)
304806
public function notify() {
		if ( $this->requirements_met() ) {
			return;
		}

		echo '<div class="notice notice-error">';

		foreach ( $this->requirements as $requirement ) {
			if ( $requirement->is_met() ) {
				continue;
			}

			printf(
				'<p>%s deactivated: %s</p>',
				esc_html( $this->name ),
				esc_html( $requirement->get_message() )
			);
		}

		echo '</div>';
	}
24365
public function notify()
    {
        $notice['facId'] = isset($_REQUEST['facId']) ? $_REQUEST['facId'] : '';
        $notice['facMemId'] = isset($_REQUEST['facMemId']) ? $_REQUEST['facMemId'] : '';
        $notice['facTradeSeq'] = isset($_REQUEST['facTradeSeq']) ? $_REQUEST['facTradeSeq'] : '';
        $notice['tradeSeq'] = isset($_REQUEST['tradeSeq']) ? $_REQUEST['tradeSeq'] : '';
        $notice['CardId'] = isset($_REQUEST['CardId']) ? $_REQUEST['CardId'] : '';
        $notice['oProjNo'] = isset($_REQUEST['oProjNo']) ? $_REQUEST['oProjNo'] : '';
        $notice['CardKind'] = isset($_REQUEST['CardKind']) ? $_REQUEST['CardKind'] : '';
        $notice['CardPoint'] = isset($_REQUEST['CardPoint']) ? $_REQUEST['CardPoint'] : '';
        $notice['ReturnMsgNo'] = isset($_REQUEST['ReturnMsgNo']) ? $_REQUEST['ReturnMsgNo'] : '';
        $notice['ErrorMsgNo'] = isset($_REQUEST['ErrorMsgNo']) ? $_REQUEST['ErrorMsgNo'] : '';
        $notice['ErrorMsg'] = isset($_REQUEST['ErrorMsg']) ? $_REQUEST['ErrorMsg'] : '';
        $hash = isset($_REQUEST['hash']) ? $_REQUEST['hash'] : '';

        // 签名验证
        $str = '';
        $str .= $this->config['app_key1'];
        $str .= $notice['facId'];
        $str .= $notice['facMemId'];
        $str .= $notice['facTradeSeq'];
        $str .= $notice['tradeSeq'];
        $str .= $notice['CardId'];
        $str .= $notice['oProjNo'];
        $str .= $notice['CardKind'];
        $str .= $notice['CardPoint'];
        $str .= $notice['ReturnMsgNo'];
        $str .= $notice['ErrorMsgNo'];
        $str .= $notice['ErrorMsg'];
        $str .= $this->config['app_key2'];

        $transactionId = $notice['facTradeSeq'];

        if (hash('sha256', $str) != $hash) {
            throw new DefaultException('sign error');
        }

        $result = [
            'isSuccessful'         => true,
            'message'              => 'success',
            'transactionId'        => $transactionId,
            'transactionReference' => $notice['tradeSeq'],
            'amount'               => $notice['CardPoint'],
            'currency'             => 'TWD',
            'raw'                  => $notice,
        ];
        return $result;
    }
109229
def notify(self, message):
        
        for regex, handler in self.dispatch.items():
            match = re.search(regex, message)
            if match:
                handler = getattr(self, handler)
                return handler(match)
588208
function notify(api) {
  api = createApi(api);
  reactApis.push(api);
  subsciptions.forEach(function(fn) {
    fn(api);
  });
}
1189731
def _send_notification(self, handle, payload):
        

        self.bable.notify(
            connection_handle=self._connection_handle,
            attribute_handle=handle,
            value=payload
        )
214121
def notify_all(self):
        """"""
        self.condition.acquire()
        # python 3.x
        try:
            self.condition.notify_all()
        except:
            self.condition.notifyAll()
        self.condition.release()
539536
protected void notifyRequestListeners(RequestNotifierAction action, HttpServletRequest req, HttpServletResponse resp) throws IOException {
		// notify any listeners that the config has been updated
		IServiceReference[] refs = null;
		try {
			refs = getPlatformServices().getServiceReferences(IRequestListener.class.getName(),  "(name="+getName()+")"); //$NON-NLS-1$ //$NON-NLS-2$
		} catch (PlatformServicesException e) {
			if (log.isLoggable(Level.SEVERE)) {
				log.log(Level.SEVERE, e.getMessage(), e);
			}
		}
		if (refs != null) {
			for (IServiceReference ref : refs) {
				IRequestListener listener = (IRequestListener)getPlatformServices().getService(ref);
				try {
					if (action == RequestNotifierAction.start) {
						listener.startRequest(req, resp);
					} else {
						listener.endRequest(req, resp);
					}
				} finally {
					getPlatformServices().ungetService(ref);
				}
			}
		}
	}
1356933
function notify () {
    const newId = options.peerId
    const peerIds = Object.keys(peerTable)
    // check for all the peers
    // if same id skip
    // if notify === false skip
    // check the first finger that matches the criteria for ideal or next to ideal
    peerIds.forEach((peerId) => {
      if (newId === peerId) {
        return // skip ourselves
      }
      if (!peerTable[peerId].notify) {
        return // skip if it doesn't want to be notified of available peers
      }

      // if it had none, notify to get a successor
      if (peerTable[peerId].fingers['0'].current === undefined) {
        peerTable[peerId].fingers['0'].current = newId
        peerTable[peerId].socket.emit('we-update-finger', {
          row: '0',
          id: newId
        })
        return
      }

      const rows = Object.keys(peerTable[peerId].fingers)
      // find the first row that could use this finger
      rows.some((row) => {
        const finger = peerTable[peerId].fingers[row]
        const bestCandidate = fingerBestFit(
            new Id(peerId),
            new Id(finger.ideal),
            new Id(finger.current),
            new Id(newId))
        if (bestCandidate) {
          peerTable[peerId].fingers[row].current = newId
          peerTable[peerId].socket.emit('we-update-finger', {
            row: row,
            id: newId
          })
          return true
        }
      })
    })
  }
1155058
def notify_message(self, message, level="info", clear_if_dupl=True,
                       clear_in=CLEAR_NOTIF_BAR_MESSAGE_IN):
        
        with self.notifications_lock:
            if clear_if_dupl and message in self.message_widget_dict.keys():
                logger.debug("notification %r is already displayed", message)
                return
            logger.debug("display notification %r", message)
            widget = urwid.AttrMap(urwid.Text(message), "notif_{}".format(level))
        return self.notify_widget(widget, message=message, clear_in=clear_in)