Operation deleteStoreCreditPaymentByIdAsyncWithHttpInfo

Delete StoreCreditPayment

@param  string $store_credit_payment_id ID of storeCreditPayment to delete. (required)

@throws \InvalidArgumentException
@return \GuzzleHttp\Promise\PromiseInterface
347884
protected static function deleteStoreCreditPaymentByIdAsyncWithHttpInfo($store_credit_payment_id) 
    {
        $returnType = '';  
        $request = self::deleteStoreCreditPaymentByIdRequest($store_credit_payment_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()
                    );
                }
            );
    }
855430
@Override
	public void removeByC_I(long commerceOrderId, long CPInstanceId) {
		for (CommerceOrderItem commerceOrderItem : findByC_I(commerceOrderId,
				CPInstanceId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
			remove(commerceOrderItem);
		}
	}
1192976
function remove( $key, $store = true ) {
			if ( ! array_key_exists( $key, $this->_data ) ) {
				return;
			}

			unset( $this->_data[ $key ] );

			if ( $store ) {
				$all_data                 = $this->get_all_data();
				$all_data[ $this->_secondary_id ] = $this->_data;
				$options_manager          = $this->get_option_manager();
				$options_manager->set_option( $this->_id, $all_data, true );
			}
		}
640217
public function deleteCard($addressBookId, $cardUri)
    {
        $stmt = $this->pdo->prepare('DELETE FROM '.$this->cardsTableName.' WHERE addressbookid = ? AND uri = ?');
        $stmt->execute([$addressBookId, $cardUri]);

        $this->addChange($addressBookId, $cardUri, 3);

        return 1 === $stmt->rowCount();
    }
1160369
public function delete($commentId)
    {
        $db = $this->getDb();
        $db->startTransaction();

        $deleteResult = $db->execute('DELETE FROM `oepaypal_orderpaymentcomments` WHERE `oepaypal_commentid` = ' . $db->quote($commentId));

        $result = ($deleteResult !== false);

        if ($result) {
            $db->commitTransaction();
        } else {
            $db->rollbackTransaction();
        }

        return $result;
    }
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));
  }
1266185
public function delete($order_id)
    {
        $result = null;
        $this->hook->attach('order.delete.before', $order_id, $result, $this);

        if (isset($result)) {
            return (bool) $result;
        }

        $result = (bool) $this->db->delete('orders', array('order_id' => $order_id));

        if ($result) {
            $this->deleteLinked($order_id);
        }

        $this->hook->attach('order.delete.after', $order_id, $result, $this);
        return (bool) $result;
    }
1281016
public function delete($id)
    {
        $this->validateId($id);

        $entity = $this->getMapper()->find($id);

        if (null === $entity) {
            throw new \InvalidArgumentException('No entity found for id "' . $id . '"');
        }

        $this->getMapper()->remove($entity);

        return $this;
    }
637289
public function deleteCustomer($param)
    {
        $param['method'] = CheckoutApi_Client_Adapter_Constant::API_DELETE;
        $this->flushState();
        $uri = $this->getUriCustomer();
        $hasError = false;
        $isCustomerIdValid = CheckoutApi_Client_Validation_GW3::isCustomerIdValid($param);
        if(!$isCustomerIdValid) {
            $hasError = true;
            $this->throwException('Please provide a valid customer id',array('param'=>$param));
        }else {

            $uri = "$uri/{$param['customerId']}";
        }

        return $this->request( $uri ,$param,!$hasError);
    }
693796
public function delete($customer, $forceDelete = false)
    {
        $id = null;
        if ($customer instanceof HpsPayPlanCustomer) {
            $id = $customer->customerKey;
        } else {
            $id = $customer;
        }

        $data = array(
            'forceDelete' => $forceDelete,
        );
        return $this->doRequest($data, array(
            'verb'     => 'DELETE',
            'endpoint' => 'customers/'.$id,
        ));
    }
744258
protected static function deletePaymentTokenByIdAsyncWithHttpInfo($payment_token_id) 
    {
        $returnType = '';  
        $request = self::deletePaymentTokenByIdRequest($payment_token_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()
                    );
                }
            );
    }
149844
static function cleanupOrder( $orderID )
    {
        $db = eZDB::instance();
        $orderID =(int) $orderID;
        $rows = $db->arrayQuery( "SELECT productcollection_id, order_nr FROM ezorder WHERE id='$orderID'" );
        if ( count( $rows ) > 0 )
        {
            // Who deletes which order in shop should be logged.
            eZAudit::writeAudit( 'order-delete', array( 'Order ID' => $orderID,
                                                        'Comment' => 'Removed the order and its related data from the database: eZOrder::cleanupOrder()' ) );

            $productCollectionID = $rows[0]['productcollection_id'];
            $orderNr = (int)$rows[0]['order_nr'];
            $db = eZDB::instance();
            $db->begin();
            $db->query( "DELETE FROM ezorder where id='$orderID'" );
            $db->query( "DELETE FROM ezproductcollection where id='$productCollectionID'" );
            $db->query( "DELETE FROM ezproductcollection_item where productcollection_id='$productCollectionID'" );
            $db->query( "DELETE FROM ezorder_status_history WHERE order_id=$orderNr" );
            $db->commit();
        }
    }
1254494
public function deleteProduct($product_id)
    {
        if (isset($this->_products[$product_id]["trial"]))
        {
            $this->deleteTrial($product_id);
        }
        if (isset($this->_products[$product_id]["subscription"]))
        {
            $this->deleteSubscription($product_id);
        }
        if (isset($this->_products[$product_id]["payment_plan"]))
        {
            $this->deletePaymentPlan($product_id);
        }
        unset($this->_products[$product_id]);

        return $this->_products;
    }
1132567
public function editStore($store_id = null)
    {
        $this->setStore($store_id);
        $this->seTitleEditStore();
        $this->setBreadcrumbEditStore();

        $this->setData('store', $this->data_store);
        $this->setData('themes', $this->getListThemeStore());
        $this->setData('is_default', $this->isDefaultStore());
        $this->setData('can_delete', $this->canDeleteStore());
        $this->setData('countries', $this->getCountriesStore());
        $this->setData('collections', $this->getListCollectionStore());
        $this->setData('languages', $this->language->getList(array('enabled' => true)));

        $this->submitEditStore();
        $this->setDataEditStore();

        $this->setJsEditStore();
        $this->outputEditStore();
    }
13597
function remove(id, store) {
      var data = store.rootData.asObject();
      // Check id coincidence
      if (data[id.toString()]) {
        var deleted = JSON.stringify(data[id.toString()]);
        // Delete item
        delete data[id.toString()];
        // Update store data
        store.rootData = store.data = new Result(data, store, store.data.__sorted);
        // Update store data items length
        store.size = Object.keys(store.data).length;
        // Trigger onSourceChanged event
        vcomet.triggerCallback("onSourceChanged", store);
        return JSON.parse(deleted);
      } else {
        // Item not found warning
        return vcomet.error.log("store", "Item with id " + id + " not found");
      }
    }
1355162
protected function deleteCacheValues($key, RedisClient $connection, Repository $store)
    {
        $members = $connection->smembers($key);

        foreach ($members as $member) {
            $store->forget($member);
        }
    }
406417
def remove_token(self, *, payer_id, credit_card_token_id):
        
        payload = {
            "language": self.client.language.value,
            "command": PaymentCommand.REMOVE_TOKEN.value,
            "merchant": {
                "apiLogin": self.client.api_login,
                "apiKey": self.client.api_key
            },
            "removeCreditCardToken": {
                "payerId": payer_id,
                "creditCardTokenId": credit_card_token_id
            },
            "test": self.client.is_test
        }
        return self.client._post(self.url, json=payload)