function testConstructWithObject() { Config::setIdSeparator(false); $address = new Address(array('first_name' => 'Hans', 'last_name' => 'Müller', 'address1' => 'Domstr. 12', 'city' => 'München', 'zip_code' => '80234', 'country' => 'DE')); $this->assertEqual('Hans', $address->first_name); $this->assertEqual('DE', $address->country); $data = array('type' => 'MobilePayment', 'amount' => 3000, 'currency' => 'CHF', 'usage' => 'the usage', 'transaction_id' => 'test-1234', 'notification_url' => 'https://my-server.com/hypercharge/notification.php', 'billing_address' => $address); $r = new PaymentRequest($data); $r->validate(); $this->assertIsA($r->billing_address, 'Hypercharge\\Address'); $this->assertEqual($r->billing_address->first_name, 'Hans'); $serializer = new XmlSerializer(); $str = $serializer->toXml($r); $this->assertEqual('<?xml version="1.0" encoding="UTF-8"?> <payment> <type>MobilePayment</type> <amount>3000</amount> <currency>CHF</currency> <usage>the usage</usage> <transaction_id>test-1234</transaction_id> <notification_url>https://my-server.com/hypercharge/notification.php</notification_url> <billing_address> <first_name>Hans</first_name> <last_name>Müller</last_name> <address1>Domstr. 12</address1> <city>München</city> <zip_code>80234</zip_code> <country>DE</country> </billing_address> </payment> ', $str); }
/** * @param Hypercharge\IUrl $url * @param Hypercharge\IRequest $request * @return Hypercharge\IResponse * @throws Hypercharge\Error */ public function call(IUrl $url, IRequest $request) { $curl = Config::getFactory()->createHttpsClient(Config::getUser(), Config::getPassword()); $serializer = new XmlSerializer(); $responseStr = $curl->xmlPost($url->get(), $serializer->toXml($request)); $responseDom = new \SimpleXMLElement($responseStr); return $request->createResponse(XmlSerializer::dom2hash($responseDom)); }
function testSerialize() { $c = new SimplePaymentReturningRequest('cancel', '345'); $serializer = new XmlSerializer(); $str = $serializer->toXml($c); $this->assertEqual('<?xml version="1.0" encoding="UTF-8"?> <cancel> <unique_id>345</unique_id> </cancel> ', $str); }
function toXml($all, \DOMNode $parent) { if (!sizeof($all)) { return; } foreach ($all as $m) { XmlSerializer::addChild($parent, 'payment_method', $m); } }
/** * @param array $all array of string * @param DOMNode $parent the xml node receiving items of $all <transaction_type>ITEM</transaction_type> * @return void */ function toXml($all, \DOMNode $parent) { if (!sizeof($all)) { return; } foreach ($all as $t) { XmlSerializer::addChild($parent, 'transaction_type', $t); } }
function testToXmlWithNull() { $data = null; $t = new PaymentMethods(); $parent = XmlSerializer::createDocument('payment_methods'); $t->toXml($data, $parent); $this->assertEqual($parent->ownerDocument->saveXml(), '<?xml version="1.0" encoding="UTF-8"?> <payment_methods/> '); }
function testToXmlWithNull() { $data = null; $t = new TransactionTypes(); $parent = XmlSerializer::createDocument('transaction_types'); $t->toXml($data, $parent); $this->assertEqual($parent->ownerDocument->saveXml(), '<?xml version="1.0" encoding="UTF-8"?> <transaction_types/> '); }
function testSerializeXmlShouldHandleNull() { $o = new SerializableImpl(array('leer' => null)); $root = XmlSerializer::createDocument('r'); XmlSerializer::_toXml($o, $root); $str = $root->ownerDocument->saveXML(); $this->assertEqual('<?xml version="1.0" encoding="UTF-8"?> <r> <leer/> </r> ', $str); }
function test_toXmlRecursiveSorted() { $a = new Address($this->fixture('address.json')); $a->foo = new MpiParams(array('x' => '1', 'a' => '2', 'k' => '3')); XmlSerializer::$sort = true; $root = XmlSerializer::createDocument('r'); XmlSerializer::_toXml($a, $root); $str = $root->ownerDocument->saveXML(); $this->assertEqual($str, '<?xml version="1.0" encoding="UTF-8"?> <r> <address1>Kurfürstendamm 123</address1> <city>Berlin</city> <country>DE</country> <first_name>Hans</first_name> <foo> <a>2</a> <k>3</k> <x>1</x> </foo> <last_name>Johanson</last_name> <zip_code>10624</zip_code> </r> '); }
/** * Creates the headers and body of HTTP upload request that will be used to * upload batch operations to. * * @param array $operations operations to be uploaded to the upload URL * @return array an associative array containing the headers and body of HTTP * upload request */ private function PrepareUploadRequest(array $operations) { $headers = array('Content-Type' => self::$UPLOAD_URL_HEADER_CONTENT_TYPE); $batchJobOpsMutate = new BatchJobOpsMutate(); $batchJobOpsMutate->operations = $operations; // Get body of this HTTP upload request. $serializer = new XmlSerializer(); $xml = $serializer->ConvertObjectToXml($batchJobOpsMutate, 'ns1:mutate', true); return array('headers' => $headers, 'body' => $xml); }
/** * Creates the HTTP headers and body for incremental upload request that will * be used to upload batch operations to. Content-Length and Content-Range * are required for incremental upload. * * @param array $operations operations to be uploaded to the upload URL * @param bool $isLastRequest if this is last upload request * @return array an associative array containing the HTTP headers, body, and * content length of incremental upload request */ private function PrepareIncrementalUploadRequest(array $operations, $isLastRequest) { $headers = array('Content-Type' => self::$UPLOAD_URL_HEADER_CONTENT_TYPE); $batchJobOpsMutate = new BatchJobOpsMutate(); $batchJobOpsMutate->operations = $operations; // Get body of this HTTP upload request. $serializer = new XmlSerializer(); $content = $this->PostProcessContent($serializer->ConvertObjectToXml($batchJobOpsMutate, 'ns1:mutate', true), $this->totalContentBytes == 0, $isLastRequest); $contentLength = mb_strlen($content, '8bit'); $headers['Content-Length'] = $contentLength; // On the last request, specify the total number of bytes. // e.g., bytes 500-999/1000 $lowerBound = $this->totalContentBytes; $upperBound = $this->totalContentBytes + $contentLength - 1; $totalBytes = $isLastRequest ? strval($upperBound + 1) : '*'; $contentRange = sprintf('bytes %d-%d/%s', $lowerBound, $upperBound, $totalBytes); $headers['Content-Range'] = $contentRange; return array('headers' => $headers, 'body' => $content, 'length' => $contentLength); }
/** * @covers XmlSerializer::ConvertObjectToXml * @covers XmlSerializer::ConvertObjectToElement * @covers XmlSerializer::ConvertObjectToNodeValue */ public function testConvertObjectToXmlMutateRequest() { $serializer = new XmlSerializer(); $result = $serializer->ConvertObjectToXml(XmlTestHelper::$MUTATE_REQUEST_OBJECT, 'ns1:mutate', true); $this->assertEquals(XmlTestHelper::$NAMESPACED_MUTATE_REQUEST_XML, $result); }
/** * In order hypercharge knows the notification has been received and processed successfully by your server * you have to respond with an ack message. * <pre> * die($notifiction->ack()) * </pre> * * If you do not do so, hypercharge will send the notification again later (up to 10 times at increasing intervals). * This also applies to accidentally polluting the output with php error-, warning- or notice-messages (invalid xml). * * * fyi: ack() returns an xml string e.g. * * <?xml version="1.0" encoding="UTF-8"?> * <notification_echo> * <unique_id>26aa150ee68b1b2d6758a0e6c44fce4c</unique_id> * </notification_echo> * * @return string xml */ function ack() { $root = XmlSerializer::createDocument('notification_echo'); XmlSerializer::addChild($root, 'unique_id', $this->payment_unique_id); return $root->ownerDocument->saveXml(); }
function parseResponseFixture($xmlFile) { $dom = new \SimpleXMLElement($this->fixture($xmlFile)); return XmlSerializer::dom2hash($dom); }
function testGetTransaction() { XmlSerializer::$sort = false; // prepare post, request, response fixtures $postData = $this->schemaNotification('transaction_notification.json'); $channel_token = $postData['channel_token']; $uid = $postData['unique_id']; $requestXml = $this->schemaRequest('reconcile.xml'); $requestXml = preg_replace('/<unique_id>[^<]+<\\/unique_id>/', "<unique_id>{$uid}</unique_id>", $requestXml); $responseXml = $this->schemaResponse('reconcile.xml'); $responseXml = preg_replace('/<unique_id>[^<]+<\\/unique_id>/', "<unique_id>{$uid}</unique_id>", $responseXml); $this->curlMock()->shouldReceive('xmlPost')->with("https://test.hypercharge.net/reconcile/{$channel_token}", $requestXml)->once()->andReturn($responseXml); // actually test the notification $tn = new TransactionNotification($postData); $this->assertTrue($tn->hasTransaction()); $trx = $tn->getTransaction(); $this->assertIsA($trx, 'Hypercharge\\Transaction'); $this->assertTrue($trx->isApproved()); $this->assertEqual($trx->unique_id, $uid); }
/** * @private * @param string $action * @param string $channelToken * @param string $unique_id * @return Hypercharge\Transaction */ static function request($action, $channelToken, $unique_id) { $url = new TransactionUrl(Config::ENV_SANDBOX, $channelToken, $action); $url = $url->get() . '/' . $unique_id; $curl = new Curl(Config::getUser(), Config::getPassword()); $responseStr = $curl->xmlPost($url, ''); $responseDom = new \SimpleXMLElement($responseStr); // dummy $request = new TransactionRequest(array('transaction_type' => 'sale')); return $request->createResponse(XmlSerializer::dom2hash($responseDom)); }
/** * Generates the parameters to use for the download request. * @param mixed $reportDefinition the report definition, as an ID or object * @return array the parameters */ private static function GetParams($reportDefinition) { $params = array(); if (is_numeric($reportDefinition)) { $params['__rd'] = $reportDefinition; } else { if (is_object($reportDefinition) || is_array($reportDefinition)) { $serializer = new XmlSerializer(); $params['__rdxml'] = $serializer->ConvertObjectToXml($reportDefinition, 'reportDefinition', false); } else { throw new ReportDownloadException('Invalid report definition type: ' . $reportDefinition); } } return $params; }
<?php function callback_trim($buffer) { return trim($buffer); } ob_start("callback_trim"); include 'const.php'; include 'autoload.php'; $db = new MySQL('system/dbsettings.php'); $db->Connect(); $language = new Language(); $datatype = new DataType($_GET['datatype']); $serializer = new XmlSerializer(); if (isset($_GET['apikey']) && $datatype->allowShare($_GET['apikey'])) { if ($_GET['action'] == "export") { $list = $datatype->getAll(); $serializer->serialize($list, $datatype); } //At this time to unsafe /*else if($_GET['action'] == "import" && $_GET['url'] != ""){ $serializer->importFromUrl($_GET['url']); }*/ } else { $serializer->raiseError("1", "Access denied."); } ob_flush();
function setUp() { $this->serializer = new XmlSerializer(new XmlMapping()); XmlSerializer::$sort = false; }
if ($clean) { Freezer::clean('cache', 'nodes'); Freezer::clean('cache', 'resources'); if ($kwargs['outfile']) { if (isset($kwargs['serialize']['json'])) { JsonSerializer::clean('cache', 'json', $kwargs['outfile']); } if (isset($kwargs['serialize']['xml'])) { XmlSerializer::clean('cache', 'xml', $kwargs['outfile']); } } else { if (isset($kwargs['serialize']['json'])) { JsonSerializer::clean('cache', 'json'); } if (isset($kwargs['serialize']['xml'])) { XmlSerializer::clean('cache', 'xml'); } } } $files = dojo_get_files($args); $nodes = new Freezer('cache', 'nodes'); $resources = new Freezer('cache', 'resources'); print "=== PARSING FILES ===\n"; flush(); foreach ($files as $set) { list($namespace, $file) = $set; if (!$namespaces[$namespace]) { $namespaces[$namespace] = true; } $ctime = dojo_get_file_time($namespace, $file); if ($ctime == $resources->open($namespace . '%' . $file, null)) {
} } if (!$has_children) { unset($roots[$id]); } } } } print "=== SERIALIZING OBJECTS ===\n"; // Aggregate and save if ($outfile) { $json = new JsonSerializer('cache', 'json', $outfile); $xml = new XmlSerializer('cache', 'xml', $outfile); } else { $json = new JsonSerializer('cache', 'json'); $xml = new XmlSerializer('cache', 'xml'); } foreach ($roots as $id => $root) { if (!$id) { // Minor bug continue; } $node = $nodes->open($id, null); $parts = explode('.', $id); foreach ($ids as $child_id) { $child_parts = explode('.', $child_id); if (count($child_parts) == count($parts) + 1 && strpos($child_id, "{$id}.") === 0 && !array_key_exists($child_id, $roots)) { $node['#children'][array_pop($child_parts)] = $nodes->open($child_id, null); } } print "{$id}\t\t" . memory_get_usage() . "\n";