Deletes an alert including its notifications and triggers.

@param   alertId  The ID of the alert to delete.

@throws  IOException  If the server cannot be reached.
@throws  TokenExpiredException   If the token sent along with the request has expired
182953
public void deleteAlert(BigInteger alertId) throws IOException, TokenExpiredException {
        String requestUrl = RESOURCE + "/" + alertId.toString();
        ArgusResponse response = getClient().executeHttpRequest(ArgusHttpClient.RequestType.DELETE, requestUrl, null);

        assertValidResponse(response, requestUrl);
    }
270985
public final void validateExpiration() throws TokenExpiredException {
        Date d = new Date();
        Date expD = new Date(getExpiration());
        boolean expired = d.after(expD);
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(this, tc, "Current time = " + d + ", expiration time = " + expD);
        }
        if (expired) {
            String msg = "The token has expired: current time = \"" + d + "\", expire time = \"" + expD + "\"";
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(this, tc, msg);
            }
            throw new TokenExpiredException(expirationInMilliseconds, msg);
        }
    }
620875
public void alertClose() {
        if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE))  //306998.15
            logger.logp(Level.FINE, CLASS_NAME,"alertClose", " _outWriter: --> " + _outWriter);
        // 104771
        writerClosed = true;

        if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE))  //306998.15
            logger.logp(Level.FINE, CLASS_NAME,"alertClose", "exit");
    }
1163891
public void api_application_applicationId_DELETE(Long applicationId) throws IOException {
		String qPath = "/me/api/application/{applicationId}";
		StringBuilder sb = path(qPath, applicationId);
		exec(qPath, "DELETE", sb.toString(), null);
	}
577145
protected void deleteApiKeyInternal(final ObjectId id) {
    final StitchAuthRequest.Builder reqBuilder = new StitchAuthRequest.Builder();
    reqBuilder
            .withMethod(Method.DELETE)
            .withPath(routes.getApiKeyRouteForId(id.toHexString()))
            .withRefreshToken();
    getRequestClient().doAuthenticatedRequest(reqBuilder.build());
  }
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;
    }
1030780
def delete_alert(self, email, alert_id):
        
        data = {'email': email,
                'alert_id': alert_id}
        return self.api_delete('alert', data)
1025360
public DeleteResponse deleteDoc(String index, String type, String id) {
		return deleteQuery(esClient.prepareDelete(index, type, id));
	}
135011
public synchronized void removeId(@Nonnull String tokenUuid) {
        if(areStatsDisabled()){
            return;
        }
        
        boolean tokenRemoved = tokenStats.removeIf(s -> s.tokenUuid.equals(tokenUuid));
        if (tokenRemoved) {
            save();
        }
    }
1284161
private void sendClosingSignal() {
        URL clientURL = null;
        HttpsURLConnection connection = null;
        try {
            // Get the appropriate URL to delete notification client
            if (serverConnection.serverVersion >= 4) {
                //V4+ clients use /{clientID} to delete the notification client
                clientURL = getNotificationClientURL();
            } else {
                //Pre-V4 clients use /{clientID}/inbox to delete the notification client
                clientURL = getInboxURL();
            }

            if (logger.isLoggable(Level.FINEST)) {
                logger.logp(Level.FINEST,
                            logger.getName(),
                            "sendClosingSignal",
                            "Making a call to delete inbox [" + clientURL + "] from ["
                                            + RESTClientMessagesUtil.getObjID(this) + "]");
            }
            // Get connection to server
            connection = serverConnection.getConnection(clientURL, HttpMethod.DELETE, true);
            connection.setReadTimeout(serverConnection.getConnector().getReadTimeout());

            // Check response code from server
            int responseCode = 0;
            try {
                responseCode = connection.getResponseCode();
            } catch (ConnectException ce) {
                logger.logp(Level.FINE, logger.getName(), "sendClosingSignal", ce.getMessage(), ce);
            }

            if (logger.isLoggable(Level.FINEST)) {
                logger.logp(Level.FINEST, logger.getName(), "sendClosingSignal", "Response code: " + responseCode);
            }

        } catch (IOException io) {
            logger.logp(Level.FINE, logger.getName(), "sendClosingSignal", io.getMessage(), io);
        }
    }
335823
public static void delete(final BandwidthClient client, final String domainId, final String endpointId, final String token) throws AppPlatformException, ParseException, IOException {
        assert(client != null && domainId != null && endpointId != null && endpointId != null);
        deleteToken(client, domainId, endpointId, token);
    }
963723
@Override
    public void delete(final I id) {
        if (entity != null) {
            inTransaction(
                    new Callable<Void>() {
                        @Override
                        public Void call() throws Exception {
                            final T entity = findOne(id);
                            T attached = getAttached(entity);
                            if (attached != null) {
                                entityManager.remove(attached);
                            }
                            return null;
                        }
                    }
            );
        }
    }
345480
public void deleteVoiceMessage(final String id) throws UnauthorizedException, GeneralException, NotFoundException {
        if (id == null) {
            throw new IllegalArgumentException("Message ID must be specified.");
        }
        messageBirdService.deleteByID(VOICEMESSAGESPATH, id);
    }
1173362
public void delete(String targetId) throws IOException {
        startChangesIfNecessary();
        ResponseWriter writer = getWrapped();
        writer.startElement("delete", null);
        writer.writeAttribute("id", targetId, null);
        writer.endElement("delete");
    }
416518
@Override
    public final boolean delete(Context cx, Object id) {
        if (cx == null) cx = Context.getCurrentContext();
        XMLName xmlName = lib.toXMLNameOrIndex(cx, id);
        if (xmlName == null) {
            long index = ScriptRuntime.lastUint32Result(cx);
            // XXX Fix this
            delete((int)index);
            return true;
        }
        deleteXMLProperty(xmlName);
        return true;
    }
431678
@Override
	public void remove(String oid) throws IndexerException {
		log.debug("Deleting " + oid + " from index");
		try {
			solr.deleteByQuery("storage_id:\"" + oid + "\"");
			solr.commit();
		} catch (SolrServerException sse) {
			throw new IndexerException(sse);
		} catch (IOException ioe) {
			throw new IndexerException(ioe);
		}
	}
307009
public void deleteServerRegistrationHTTP(RESTRequest request,
                                             int clientID,
                                             ServerNotificationRegistration serverNotificationRegistration,
                                             String registrationID,
                                             JSONConverter converter) {
        //Get the client area
        ClientNotificationArea clientArea = getInboxIfAvailable(clientID, null);

        if (registrationID != null) {
            String[] artifacts = registrationID.split("_");
            int filterID = Integer.parseInt(artifacts[0]);
            int handbackID = Integer.parseInt(artifacts[1]);

            //Since this is not coming from our java client, the registration object will not have any IDs on them. So set the IDs before continuing.
            serverNotificationRegistration.filterID = filterID;
            serverNotificationRegistration.handbackID = handbackID;
        }

        clientArea.removeServerNotificationListener(request, serverNotificationRegistration, serverNotificationRegistration.operation == Operation.RemoveAll, converter,
                                                    true);
    }