delete member record partial
973046
function deleteRecord(rType, idFun) {
  return function(item, callback) {
    GLOBAL.debug('deleting', item, rType);
    var tc = [];
    getEs().delete({ _type: rType, _id : encodeURIComponent(idFun(item))}, function(err, deleteRes) {
      callback(err, deleteRes);
    });
  };
}
1042712
def _exclude(self, member):
        '''
        
        '''
        if isinstance(member, string_types):
            return None

        for item in self.opts['spm_build_exclude']:
            if member.name.startswith('{0}/{1}'.format(self.formula_conf['name'], item)):
                return None
            elif member.name.startswith('{0}/{1}'.format(self.abspath, item)):
                return None
        return member
372236
def delete(user_id):
        '''
        
        '''
        try:
            del_count = TabMember.delete().where(TabMember.uid == user_id)
            del_count.execute()
            return True
        except:
            return False
1098758
def delete(self):
        """"""
        pipeline = self.db.pipeline()
        self._delete_from_indices(pipeline)
        self._delete_membership(pipeline)
        pipeline.delete(self.key())
        pipeline.execute()
54505
def remove_member(self, member, api=None):
        
        api = api or self._API
        username = Transform.to_member(member)

        api.delete(
            url=self._URL['member'].format(
                id=self.id,
                username=username
            )
        )
637547
def remove(self, record):
        """"""
        self._field.validate_value(record)
        del self._elements[record.id]
        self._sync_field()
1097092
@UpdateHandler(name = "delete_record", file = "RegisteredServiceDocument_delete.js")
    public void deleteRecord(final RegisteredServiceDocument record) {
        db.callUpdateHandler(stdDesignDocumentId, "delete_record", record.getId(), null);
    }
1041247
function completeConnector(partial = {}, full) {
    const checkAndAssign = (methodName) => {
        if (typeof partial[methodName] === 'undefined') {
            partial[methodName] = full[methodName]; // eslint-disable-line no-param-reassign
        }
    }

    checkAndAssign('create')
    checkAndAssign('read')
    checkAndAssign('update')
    checkAndAssign('delete')

    return partial
}
989697
def delete
      if self.class.hooks[:active]
        self.class.hooks[:before_delete].each do |block|
          self.class.hooks[:active] = false
          block.yield self
          self.class.hooks[:active] = true
        end
      end

      st = prepare("DELETE FROM #{table} WHERE #{pk_clause}")
      num_deleted = st.execute( *pk_values ).affected_count
      st.finish
      if num_deleted != 1
        false
      else
        if self.class.hooks[:active]
          self.class.hooks[:after_delete].each do |block|
            self.class.hooks[:active] = false
            block.yield self
            self.class.hooks[:active] = true
          end
        end
        true
      end
    end
1292423
def delete_record(self, record):
        
        self.children.remove(record.resource)
        record.delete()
398364
def _delete_record(self, identifier=None, rtype=None, name=None, content=None):
        """"""
        return self._change_record_sets('DELETE', rtype, name, content)
380692
def deleteMember(self, address, id, headers=None, query_params=None, content_type="application/json"):
        
        uri = self.client.base_url + "/network/"+id+"/member/"+address
        return self.client.delete(uri, None, headers, query_params, content_type)
1138480
private void preDelete(MembershipType type) throws Exception
   {
      for (MembershipTypeEventListener listener : listeners)
      {
         listener.preDelete(type);
      }
   }
811554
function deleteRules(rulesToDelete, cb) {
    var idsToRemove = _.pluck(rulesToDelete, "_id");

    function deleteRule(fieldRuleId, cb1) {
      rulesModel.findByIdAndRemove(fieldRuleId, cb1);
    }
    async.each(idsToRemove, deleteRule, cb);
  }
1308283
function deleteNode(record: RecordProxy, nodeID: DataID): void {
  const {EDGES, NODE} = RelayConnectionInterface.get();

  const edges = record.getLinkedRecords(EDGES);
  if (!edges) {
    return;
  }
  let nextEdges;
  for (let ii = 0; ii < edges.length; ii++) {
    const edge = edges[ii];
    const node = edge && edge.getLinkedRecord(NODE);
    if (node != null && node.getDataID() === nodeID) {
      if (nextEdges === undefined) {
        nextEdges = edges.slice(0, ii);
      }
    } else if (nextEdges !== undefined) {
      nextEdges.push(edge);
    }
  }
  if (nextEdges !== undefined) {
    record.setLinkedRecords(nextEdges, EDGES);
  }
}
470846
def delete(name, dry_run, verbose):
    """"""
    collection = Collection.query.filter_by(name=name).one()
    if verbose:
        tr = LeftAligned(traverse=AttributeTraversal())
        click.secho(tr(collection), fg='red')
    db.session.delete(collection)
1330154
def revoke_member(context, request):
    """"""

    mapping = request.json['mapping']
    for entry in mapping:
        user = entry['user']
        roles = entry['roles']
        username = user.get('username', None)
        userid = user.get('userid', None)
        if userid:
            u = context.get_user_by_userid(userid)
        elif username:
            u = context.get_user_by_username(username)
        else:
            u = None
        if u is None:
            raise UnprocessableError(
                'User %s does not exists' % (userid or username))
        for rolename in roles:
            context.revoke_member_role(u.userid, rolename)
    return {'status': 'success'}