Delete a channel
@param  {String|Integer} identifier A Robin channel identifier
@return {Function}                  A Promise
181121
function (identifier)  {
    var path;
    if (identifier) {
      path = this.constructPath(constants.CHANNELS, identifier);
      return this.Core.DELETE(path);
    } else {
      return this.rejectRequest('Bad Request: A channel identifier is required.');
    }
  }
20679
function remove(user, callback) {
      var cb = callback || angular.noop;

      return User.remove({id: user._id},
        function (user) {
          return cb(user);
        },
        function (err) {
          return cb(err);
        }).$promise;
    }
530100
def delete(context, id, etag):
    
    result = feeder.delete(context, id=id, etag=etag)

    if result.status_code == 204:
        utils.print_json({'id': id, 'message': 'Feeder deleted.'})
    else:
        utils.format_output(result, context.format)
253065
def delete(self, identifier):
        

        try:
            node = self.global_plate_definitions[identifier]
        except NodeIDAbsentError:
            logging.info("Meta data {} not present during deletion".format(identifier))
            return

        # First delete any children of the node: REMOVED as this seemed to be unreliable
        # It's now better to call delete_plate with delete_meta_data=True
        # for child in node.fpointer:
        #     self.delete(child)

        self.global_plate_definitions.remove_node(identifier)

        with switch_db(MetaDataModel, 'hyperstream'):
            meta_data = MetaDataModel.objects(tag=node.tag, data=node.data, parent=node.bpointer).first()
            if meta_data is not None:
                meta_data.delete()

        logging.info("Meta data {} deleted".format(identifier))
1136947
function (identifier) {
            var self = this;

            return self.needByIdentifier(identifier)
                .then(function (record) {
                    return self.destroy(
                       record.id
                    ).then(function (records) {
                        return records[0];
                    });
                });
        }
1154382
public static synchronized void removeChannel(String channelId) {
        try {
            if (_removeChannel(channelId)) {
                save();
            }
        } catch (Exception ex) {
            Log.e(WonderPush.TAG, "Unexpected error while removing channel " + channelId, ex);
        }
    }
286567
function unsubscribe (channels) {
    if (!isArray(channels)) channels = [channels]
    if (!every(channels, isString)) throw new TypeError(`${_debugStr}: .unsubscribe([channels]) channels must be represented by strings`)

    channels.forEach(channel => {
      if (~internalChannels.indexOf(channel)) {
        console.warn(`${_debugStr} channel '${channel}' is used internally and you cannot unsubscribe from it.`)
        return
      }
      _subConnection.unsubscribe([channel])
    })
    return node
  }
458092
def _cleanup_channel(self, channel_id):
        
        with self.lock:
            if channel_id not in self._channels:
                return
            del self._channels[channel_id]
123794
function(options) {
        if (!this.id)
          return Promise.reject(new Error('The status id is not exists.'));
        var request = AVRequest('statuses', null, this.id, 'DELETE', options);
        return request;
      }
567122
function deleteById (id, cb) {
      let promise = null
      if (typeof cb !== 'function') [promise, cb] = asyncify()

      const tasks = [
        (job, next) => {
          Joi.validate(id, validationRules.deleteById, (err) => {
            if (err) return next(Boom.badRequest(err))
            next()
          })
        },
        (job, next) => {
          job.id = id
          next()
        },
        fetchOrganizationUsers,
        removeUsersFromTeams,
        removeUsersPolicies,
        fetchOrganizationTeams,
        removeTeamsPolicies,
        clearOrganizationAttachedPolicies,
        deleteOrganizationPolicies,
        deleteOrganizationTeams,
        deleteOrganizationUsers,
        deleteOrganization
      ]

      db.withTransaction(tasks, cb)

      return promise
    }
471700
function (identifier)  {
    var path;
    if (identifier) {
      path = this.constructPath(constants.DEVICES, identifier);
      return this.Core.DELETE(path);
    } else {
      return this.rejectRequest('Bad Request: A device identifier is required.');
    }
  }
148341
@DELETE
    @Path("/{ccid: [A-Z,a-z,0-9,_,\\-,\\.]+}")
    public Response deleteChannel(@PathParam("ccid") String ccid) {
        try {
            log.info("DELETE channel for cluster controller: {}", ccid);

            if (channelService.deleteChannel(ccid)) {
                return Response.ok().build();
            }
            return Response.noContent().build();

        } catch (WebApplicationException e) {
            throw e;
        } catch (Exception e) {
            log.error("DELETE channel for cluster controller: error: {}", e.getMessage(), e);
            throw new WebApplicationException(Status.INTERNAL_SERVER_ERROR);
        }
    }
604155
function(id) {
      if (openQueue[id]) { delete openQueue[id]; }
      if (messageQueue[id]) { delete messageQueue[id]; }
      if (closeQueue[id]) { delete closeQueue[id]; }
      if (errorQueue[id]) { delete errorQueue[id]; }
    }
668018
public AlertPolicyChannelService delete(long policyId, long channelId)
    {
        QueryParameterList queryParams = new QueryParameterList();
        queryParams.add("policy_id", policyId);
        queryParams.add("channel_id", channelId);
        HTTP.DELETE("/v2/alerts_policy_channels.json", null, queryParams);       
        return this;
    }
357407
function(name, identifier) {

      if (_.isUndefined(this._events[name])) { return this; }

      if (_.isFunction(identifier)) {
        this._events[name] = _.reject(this._events[name], function(b) {
          return b.callback === identifier;
        });

      } else if ( _.isString(identifier)) {
        this._events[name] = _.reject(this._events[name], function(b) {
          return b.token === identifier;
        });

      } else {
        this._events[name] = [];
      }
      return this;
    }
823625
def RemoveObject(self, identifier):
    
    if identifier not in self._values:
      raise KeyError('Missing cached object for identifier: {0:s}'.format(
          identifier))

    del self._values[identifier]
664707
function Channel_delAgent(agent) {
  if (this.agents.get(agent.info.id) == null) return

  DEBUG("channel.delAgent(" + utils.JS(agent.info) + ")")
  this.agents.delete(agent.info.id)
  this.session.sendEvent("agentDestroyed", "server", agent.info)
}