Exclude object from result

@param   ChildCustomerCustomerGroup $customerCustomerGroup Object to remove from the list of results

@return ChildCustomerCustomerGroupQuery The current query, for fluid interface
510695
public function prune($customerCustomerGroup = null)
    {
        if ($customerCustomerGroup) {
            $this->addCond('pruneCond0', $this->getAliasedColName(CustomerCustomerGroupTableMap::CUSTOMER_ID), $customerCustomerGroup->getCustomerId(), Criteria::NOT_EQUAL);
            $this->addCond('pruneCond1', $this->getAliasedColName(CustomerCustomerGroupTableMap::CUSTOMER_GROUP_ID), $customerCustomerGroup->getCustomerGroupId(), Criteria::NOT_EQUAL);
            $this->combine(array('pruneCond0', 'pruneCond1'), Criteria::LOGICAL_OR);
        }

        return $this;
    }
154554
public function delete(Customer $customer)
    {
        $endpoint = '/admin/customers/'.$customer->id.'.json';
        $response = $this->request($endpoint, 'DELETE');
        return;
    }
313777
public function setCustomerGroupCookie($eventObject) {
        $customer = $eventObject->getCustomer();
        $cookie = Mage::getSingleton('core/cookie');
        if (Mage::getStoreConfig('persistent/options/enabled')) {
            $cookie->set('customer_group', $customer->getGroupId(), Mage::getStoreConfig('persistent/options/lifetime'));
        } else {
            $cookie->set('customer_group', $customer->getGroupId());
        }
    }
49052
public function checkCustomerHasGroup(Customer $customer, $groupCode)
    {
        $group = CustomerCustomerGroupQuery::create()
            ->filterByCustomer($customer)
            ->useCustomerGroupQuery()
            ->filterByCode($groupCode)
            ->endUse()
            ->findOne();

        return $group !== null;
    }
997482
public function setCustomer($customer)
    {
        $this->client->addQueryString('new_customer', false);

        if ($customer instanceof Customers) {
            $code = $customer->code;
        } else {
            $code = $customer;
        }

        $this->data->customer = new stdClass;
        $this->data->customer->code = $code;

        return $this;
    }
617005
public function cancelFor(Customer $customer, $subscriptionId, array $data = [])
    {
        $this->parentId = $customer->id;

        return parent::rest_delete($subscriptionId, $data);
    }
96501
public function addDefaultCustomerGroupToCustomer(CustomerEvent $event)
    {
        $defaultCustomerGroup = CustomerGroupQuery::create()->findOneByIsDefault(true);
        if (null === $defaultCustomerGroup) {
            return;
        }

        (new CustomerCustomerGroupQuery())
            ->filterByCustomerId($event->getCustomer()->getId())
            ->filterByCustomerGroupId($defaultCustomerGroup->getId())
            ->findOneOrCreate()
            ->save();
    }
771832
public function expandCustomerTransferWithProductListIds(CustomerTransfer $customerTransfer): CustomerTransfer
    {
        $customerTransfer->setCustomerProductListCollection(new CustomerProductListCollectionTransfer());

        $productListCollectionTransfer = $this->productListReader->getProductListCollectionByIdCustomerId(
            $customerTransfer
        );

        $this->addProductListsToCustomerTransfer($customerTransfer, $productListCollectionTransfer);

        return $customerTransfer;
    }
368231
public function loadByCustomerId($customerId)
    {
        $collection = $this->addFieldToFilter('customer_id', $customerId)
            ->setPageSize(1);

        if ($collection->getSize()) {
            return $collection->getFirstItem();
        }

        return false;
    }
524758
public function revokeForId($customerId, $mandateId, $data = [])
    {
        $this->parentId = $customerId;

        return parent::rest_delete($mandateId, $data);
    }
1253528
@RequestMapping(path = "/{customerId}", method = RequestMethod.DELETE)
    public ResponseEntity removeCustomer(@PathVariable("customerId") Long customerId){
        boolean succeed = customerService.removeCustomer(customerId);
        if(succeed){
            return new ResponseEntity(HttpStatus.OK);
        }else{
            return new ResponseEntity(HttpStatus.NOT_FOUND);
        }
    }
1051340
public function getCustomerLastOrderId(\Magento\Customer\Model\Customer $customer)
    {
        $storeIds = $this->storeManager->getWebsite(
            $customer->getWebsiteId()
        )->getStoreIds();

        return $this->orderCollection->create()
            ->getCustomerLastOrderId($customer, $storeIds);
    }
238356
protected static function deleteCustomerByIdAsyncWithHttpInfo($customer_id) 
    {
        $returnType = '';  
        $request = self::deleteCustomerByIdRequest($customer_id); 

        return self::getHttpClient()
            ->sendAsync($request, self::createHttpClientOption())
            ->then(
                function ($response) use ($returnType) {
                    return [null, $response->getStatusCode(), $response->getHeaders()];
                },
                function ($exception) {
                    $response = $exception->getResponse();
                    $statusCode = $response->getStatusCode();
                    throw new ApiException(
                        sprintf(
                            '[%d] Error connecting to the API (%s)',
                            $statusCode,
                            $exception->getRequest()->getUri()
                        ),
                        $statusCode,
                        $response->getHeaders(),
                        $response->getBody()
                    );
                }
            );
    }
986615
public function filterItemsForReview($items, $customerId, $order)
    {
        foreach ($items as $key => $item) {
            $productId = $item->getProduct()->getId();

            $collection = $this->reviewFactory->create()->getCollection()
                ->addCustomerFilter($customerId)
                ->addStoreFilter($order->getStoreId())
                ->addFieldToFilter('main_table.entity_pk_value', $productId);

            //remove item if customer has already placed review on this item
            if ($collection->getSize()) {
                unset($items[$key]);
            }
        }

        return $items;
    }
746008
public function buildCustomerCollection($customerIds)
    {
        $customerLog = $this->getTable('customer_log');
        $customerCollection = $this->customerCollection->create()
            ->addAttributeToSelect('*')
            ->addNameToSelect();
        $customerCollection = $this->addBillingJoinAttributesToCustomerCollection($customerCollection);
        $customerCollection = $this->addShippingJoinAttributesToCustomerCollection($customerCollection);
        $customerCollection = $customerCollection->addAttributeToFilter('entity_id', ['in' => $customerIds]);

        // get the last login date from the log_customer table
        $customerCollection->getSelect()->columns([
            'last_logged_date' => $this->expressionFactory->create(
                ["expression" => "(
                    SELECT last_login_at 
                    FROM  $customerLog 
                    WHERE customer_id =e.entity_id ORDER BY log_id DESC LIMIT 1
                )"]
            ),
        ]);

        return $customerCollection;
    }
416685
public function getProductListCollectionByIdCustomerId(
        CustomerTransfer $customerTransfer
    ): ProductListCollectionTransfer {
        $customerTransfer->requireIdCustomer();

        return $this->productListCustomerRepository
            ->getProductListCollectionByIdCustomer($customerTransfer->getIdCustomer());
    }
387967
public function getFor(Customer $customer, $subscriptionId, array $parameters = [])
    {
        $this->parentId = $customer->id;

        return parent::rest_read($subscriptionId, $parameters);
    }