Removes notification callback from the notification center

@param int $notification_id notification ID

@return true   When callback removed
false  When no callback found for the given notification ID
974449
public function removeNotificationListener($notification_id)
    {
        foreach ($this->_notifications as $notification_type => $notifications) {
            foreach (array_keys($notifications) as $id) {
                if ($notification_id == $id) {
                    unset($this->_notifications[$notification_type][$id]);
                    $this->_logger->log(Logger::INFO, "Callback with notification ID '{$notification_id}' has been removed.");
                    return true;
                }
            }
        }

        $this->_logger->log(Logger::DEBUG, "No Callback found with notification ID '{$notification_id}'.");
        return false;
    }
800384
public function destroy($id, Request $request)
    {
        $user = $request->user();
        $item = $user->notifications()->find($id);
        if (empty($item)) {
            return $this->sendError('Notification not found');
        }

        $item->delete();

        return $this->sendResponse($item, 'Notification deleted successfully.');
    }
522985
def delete(self, **kwargs):
        """"""
        url = self.base_url + '/%s' % kwargs['notification_id']
        resp = self.client.delete(url=url)
        return resp
1065517
boolean removeObserver(ApptentiveNotificationObserver observer) {
		int index = indexOf(observer);
		if (index != -1) {
			observers.remove(index);
			return true;
		}
		return false;
	}
1250116
protected synchronized boolean holdForegroundNotification(String uploadId, Notification notification) {
        if (!isExecuteInForeground()) return false;

        if (foregroundUploadId == null) {
            foregroundUploadId = uploadId;
            Logger.debug(TAG, uploadId + " now holds the foreground notification");
        }

        if (uploadId.equals(foregroundUploadId)) {
            startForeground(UPLOAD_NOTIFICATION_BASE_ID, notification);
            return true;
        }

        return false;
    }
1320576
public function unpauseCheck($check_id) {
    $this->ensureParameters(array('check_id' => $check_id), __METHOD__);
    $check = array(
      'paused' => FALSE,
    );
    return $this->modifyCheck($check_id, $check);
  }
962042
public function getNotification( $notificationId ){

        $path = sprintf( self::PATH_NOTIFICATION_LOOKUP, $notificationId );

        return $this->httpGet( $path );

    }
491338
public boolean deleteNotification(Notification notification) {
        boolean result = notification.canDelete();

        if (result) {
            broker.callRPC("RGCWXQ ALRPP", notification.getAlertId());
        }

        return result;
    }
1044937
public function clear_notifications( $queue_id ) {

		$all = get_option( $this->bucket, array() );

		if ( ! isset( $all[ $queue_id ] ) ) {
			return false;
		}

		unset( $all[ $queue_id ] );

		if ( empty( $all ) ) {
			delete_option( $this->bucket );
		} else {
			update_option( $this->bucket, $all );
		}

		return true;
	}
1194725
public function deleteTemplate($template_id)
    {

        $response = $this->rest->post(
            static::TEMPLATE_DELETE_PATH . '/' . $template_id
        );

        $this->checkResponse($response, false);

        return true;
    }
1010339
def remove_listener(self, registration_id):
        
        try:
            self._listeners.pop(registration_id)
            return True
        except KeyError:
            return False
415604
public function deleteAlert($alert_id)
    {
        if (! isset($this->config['access_token'])) {
            throw new Exception('StatHat Alerts API Access Token not set.');
        }

        $result = $this->curlDelete($this->alerts_url.'/x/'.$this->config['access_token'].'/alerts/'.$alert_id);

        return $result;
    }
186106
public function shouldReceiveNotification(Notification $notification)
    {
        $alias = get_class($notification);
        if (isset($this->notificationSettings)) {
            $settings = $this->notificationSettings;
            if (array_key_exists($alias, $settings)) {
                if ($settings[$alias] instanceof \Closure) {
                    return call_user_func($settings[$alias], $notification);
                }
                return (bool)$settings[$alias];
            }
        }
        return true;
    }
1266185
public function delete($order_id)
    {
        $result = null;
        $this->hook->attach('order.delete.before', $order_id, $result, $this);

        if (isset($result)) {
            return (bool) $result;
        }

        $result = (bool) $this->db->delete('orders', array('order_id' => $order_id));

        if ($result) {
            $this->deleteLinked($order_id);
        }

        $this->hook->attach('order.delete.after', $order_id, $result, $this);
        return (bool) $result;
    }
571419
public function see($ID)
    {
        $member = Member::currentUser();
        if (!$member) {
            return false;
        }

        if ($ID) {
            $notification = InternalNotification::get()
                ->filter([
                    'ID' => $ID,
                    'ToID' => $member->ID
                ])->first();
            if ($notification) {
                if (!$notification->IsSeen) {
                    $notification->IsSeen = true;
                    $notification->write();
                }
                return true;
            }
        }
        return false;
    }
451282
public function clearNotifications($notification_type)
    {
        $this->_logger->log(
            Logger::WARNING,
            "'clearNotifications' is deprecated. Call 'clearNotificationListeners' instead."
        );
        $this->clearNotificationListeners($notification_type);
    }
927535
public function delete()
    {
        try {
            if (is_null($id = Input::get('id'))) {
                throw new Exception('Invalid notification id provided');
            }
            $this->stack->deleteById($id);
        } catch (Exception $ex) {
            Log::alert($ex);
            return new JsonResponse(['message' => trans('antares/notifications::messages.sidebar.unable_to_delete_notification_item')], 500);
        }
    }