Process Delete a Mandates
@param \Paysafe\CustomerVault\Mandate $mandates
@return \Paysafe\CustomerVault\Mandates
@throws PaysafeException
358908
public function deleteMandates(CustomerVault\Mandates $mandates) {
        $request = new Request(array(
             'method' => Request::DELETE,
             'uri' => $this->prepareURI("/profiles/" . $mandates->profileID."/mandates/".$mandates->id),
              'body' => $mandates
            ));
        $response = $this->client->processRequest($request);
        return $response;
        
    }
320683
public function delete($merchantId, $datafeedId, $optParams = array())
  {
    $params = array('merchantId' => $merchantId, 'datafeedId' => $datafeedId);
    $params = array_merge($params, $optParams);
    return $this->call('delete', array($params));
  }
579705
protected final function delete($con = null) {
        if ($con === null) {
            $sql = new DeleteSQL();
            $sql->from($this->qualifiedName)->setDialect($this->dialect);

            return $sql;
        }
        $rst = false;
        if ($con && !is_array($con)) {
            $con = [$this->primaryKeys[0] => $con];
        }
        if (is_array($con) && $con) {
            $sql = new DeleteSQL();
            $sql->from($this->qualifiedName)->setDialect($this->dialect);
            $sql->where($con);
            $rst = $sql->exec();
            $this->checkSQL($sql);
        }

        return $rst;
    }
406552
public function deleteRole($roleId, $status = Role::STATUS_DEFINED)
    {
        $deleteRoleQuery = $this->handler->createDeleteQuery();
        if ($status !== Role::STATUS_DRAFT) {
            $deleteAssignmentsQuery = $this->handler->createDeleteQuery();
            $deleteAssignmentsQuery
                ->deleteFrom($this->handler->quoteTable('ezuser_role'))
                ->where(
                    $deleteAssignmentsQuery->expr->eq(
                        $this->handler->quoteColumn('role_id'),
                        $deleteAssignmentsQuery->bindValue($roleId, null, \PDO::PARAM_INT)
                    )
                );

            $draftCondition = $deleteRoleQuery->expr->eq(
                $this->handler->quoteColumn('version', 'ezrole'),
                $deleteRoleQuery->bindValue(Role::STATUS_DEFINED, null, \PDO::PARAM_INT)
            );
        } else {
            $draftCondition = $deleteRoleQuery->expr->neq(
                $this->handler->quoteColumn('version', 'ezrole'),
                $deleteRoleQuery->bindValue(Role::STATUS_DEFINED, null, \PDO::PARAM_INT)
            );
        }

        $deleteRoleQuery
            ->deleteFrom($this->handler->quoteTable('ezrole'))
            ->where(
                $deleteRoleQuery->expr->lAnd(
                    $deleteRoleQuery->expr->eq(
                        $this->handler->quoteColumn('id'),
                        $deleteRoleQuery->bindValue($roleId, null, \PDO::PARAM_INT)
                    ),
                    $draftCondition
                )
            );

        if ($status !== Role::STATUS_DRAFT) {
            $deleteAssignmentsQuery->prepare()->execute();
        }
        $deleteRoleQuery->prepare()->execute();
    }
978295
public function beforeDelete( $forced = false )
  {
    try {
      \DB::table(Config::get('workflow::node_user_table'))->where('node_id', $this->id)->delete();
      \DB::table(Config::get('workflow::node_role_table'))->where('node_id', $this->id)->delete();
    } catch(Execption $e) {}

    return true;
  }
810023
public function visitRequiredConstraint(ObjectValue\RequiredConstraint $constraint)
    {
        $value = $this->currentValue();
        if (
            !$value instanceof Value\ObjectValue ||
            $value->has($constraint->property())
        ) {
            return $this->createResult();
        }

        return $this->createSingleIssueResult($constraint);
    }
799711
public function delete($params=null)
    {
        self::_validateCall('delete');
        $requestor = new ApiRequestor();
        $url = '/' . $this->getType() . '/' . $this->id;
        return $requestor->request('delete', $url, $params);
    }
496515
public function delete($pattern, $handler, array $requirements = [], array $defaults = [])
    {
        $this->addRoute('DELETE', $pattern, $handler, $requirements, $defaults);
    }
159230
public function execute($params = array(), $requestParams = array()){
      
        $deleteParams = $params;
        if(count($requestParams) > 0) {
            $deleteParams = $requestParams;
        }
        $this->beginTransaction();
        $firstResult = null;
        try{
            //first delete the child tables
            $this->deleteI18nLocales($deleteParams); 
            $this->deleteOneToOneRows($deleteParams);

            //now delete the main tables
            $this->getQueryBuilder()->where($deleteParams);
            $query = $this->getQueryBuilder()->getQuery($this->entity, QueryBuilder::DELETE_QUERY);

            $firstResult = $this->query($query);

            $this->commitTransaction();
        }catch(Exception $e){
            $this->logger->addError($e->getMessage());
            $this->rollbackTransaction();
        }
        return $firstResult;

    }
398205
public void deleteObligation(final Obligation obligation, int basicBlockId)
            throws ObligationAcquiredOrReleasedInLoopException {
        Map<ObligationSet, State> updatedStateMap = new HashMap<>();
        for (Iterator<State> i = stateIterator(); i.hasNext();) {
            State state = i.next();
            checkCircularity(state, obligation, basicBlockId);
            ObligationSet obligationSet = state.getObligationSet();
            obligationSet.remove(obligation);
            if (!obligationSet.isEmpty()) {
                updatedStateMap.put(obligationSet, state);
            }
        }
        replaceMap(updatedStateMap);
    }
837771
public function getMandate($mandateId, array $parameters = [])
    {
        return $this->client->mandates->getFor($this, $mandateId, $parameters);
    }
1345065
public function delete(string $pattern, $callback, array $requirements = [])
    {
        return $this->match($pattern, $callback, $requirements, [Request::METHOD_DELETE]);
    }
22631
public function invalidate($forceForever = false)
    {
        $this->requireToken();

        $this->manager->invalidate($this->token, $forceForever);

        return $this;
    }
342235
public function deleteAction( ServerRequestInterface $request )
	{
		if( config( 'shop.authorize', true ) ) {
			$this->authorize( 'admin', [JsonadmController::class, ['admin', 'api']] );
		}

		return $this->createAdmin()->delete( $request, new Response() );
	}
1103427
public function delete($conditions = false)
    {
        $this->andWhere($conditions);
        $this->type = self::DELETE;
        return $this->execute();
    }
1112696
public function deleteClientAuthorization($clientId, $subject)
    {
        ValidationUtility::ensureStringOrInteger('$clientId', $clientId);
        ValidationUtility::ensureString('$subject', $subject);

        $request = new ClientAuthorizationDeleteRequest();
        $request->setSubject($subject);

        return $this->callServicePostApi(
            '\Authlete\Dto\ApiResponse::fromJson',
            self::$CLIENT_AUTHORIZATION_DELETE_API_PATH . $clientId,
            null, $request);
    }
1013528
public function deleteAction(Request $request)
    {
        if ($this->submitForm($this->buildForm(CsrfProtectionType::class), $request)->isValid()) {
            try {
                $this->getDomainManager()->delete($this->find('delete'));
            } catch (DomainException $e) {
                $this->processException($e);
            }
        }

        return $this->processAction('delete');
    }