public function build()
{
$this->setObjectManager($this->createEntityManager());
$this->serializerBuilder = BreezeSerializerBuilder::create($this->getObjectManager());
$this->validatorBuilder = new ValidatorBuilder();
if ($this->annotationsEnabled) {
$this->validatorBuilder->enableAnnotationMapping();
}
foreach ($this->mappings as $mapping) {
if (isset($mapping['serializer'])) {
$this->serializerBuilder->addMetadataDir($mapping['serializer']);
}
if (isset($mapping['validation'])) {
if ($mapping['type'] == 'xml') {
$this->validatorBuilder->addXmlMapping($mapping['validation']);
} else {
if ($mapping['type'] == 'yaml') {
$this->validatorBuilder->addYamlMapping($mapping['validation']);
}
}
// else if ($mapping['type'] == 'annotation') {
// $this->validatorBuilder->enableAnnotationMapping();
// }
}
}
$serializer = $this->serializerBuilder->build();
$this->setSerializer($serializer);
$validator = $this->validatorBuilder->getValidator();
$this->setValidator($validator);
}
/**
* Override default deserialization visitors
*
* @param Container $app
* @param SerializerBuilder $serializerBuilder
*/
protected function setDeserializationVisitors(Container $app, SerializerBuilder $serializerBuilder)
{
$serializerBuilder->addDefaultDeserializationVisitors();
foreach ($app["serializer.deserializationVisitors"] as $format => $visitor) {
$serializerBuilder->setDeserializationVisitor($format, $visitor);
}
}
/**
* Create a serializer instance.
*
* @return Serializer
*/
protected function createSerializer()
{
$builder = new SerializerBuilder();
$builder->addDefaultHandlers();
$builder->addDefaultDeserializationVisitors();
$builder->addDefaultSerializationVisitors();
$this->configureBuilder($builder);
return $builder->build();
}
/**
* Get API response.
*
* @param string $call
* @param string $type
* @param array $parameters
*/
public function json($call, $type, $parameters = [])
{
try {
$content = $this->plain($call, $parameters);
return $this->serializer->deserialize($content, $type, 'json');
} catch (\Exception $e) {
throw new Exception\ApiException($e->getMessage(), $call);
}
}
/**
* @param Request $request
* @param $clientId
*
* @Route("/get/tpe/from/client/{clientId}", name="getTpeFromClient", options={"expose"=true})
* @return \Symfony\Component\HttpKernel\Exception\NotFoundHttpException
*/
public function getTpeFromClientAction(Request $request, $clientId)
{
if ($request->isXmlHttpRequest() && $request->isMethod('POST')) {
$em = $this->getDoctrine()->getManager();
$serializer = new SerializerBuilder();
$clientRepository = $em->getRepository('CibLicenseBundle:Client');
$client = $clientRepository->find($clientId);
return new Response($serializer->create()->build()->serialize($client->getTpe(), 'json'), 200);
} else {
return $this->createNotFoundException('DANS TON CUL !');
}
}
/**
* Constructor.
*
* @param \net\authorize\api\contract\v1\AnetApiRequestType $request ApiRequest to send
* @param string $responseType response type expected
* @throws InvalidArgumentException if invalid request
*/
public function __construct(\net\authorize\api\contract\v1\AnetApiRequestType $request, $responseType)
{
date_default_timezone_set('UTC');
$this->logger = LogFactory::getLog(get_class($this));
if (null == $request) {
throw new InvalidArgumentException("request cannot be null");
}
if (null == $responseType || '' == $responseType) {
throw new InvalidArgumentException("responseType cannot be null or empty");
}
if (null != $this->apiResponse) {
throw new InvalidArgumentException("response has to be null");
}
$this->apiRequest = $request;
$this->validate();
$this->apiResponseType = $responseType;
$this->httpClient = new HttpClient();
$serializerBuilder = SerializerBuilder::create();
$serializerBuilder->addMetadataDir(__DIR__ . '/../../yml/v1', 'net\\authorize\\api\\contract\\v1');
//..\..\yml\v1\ //'/../lib/net/authorize/api/yml/v1'
$serializerBuilder->configureHandlers(function (HandlerRegistryInterface $h) use($serializerBuilder) {
$serializerBuilder->addDefaultHandlers();
$h->registerSubscribingHandler(new BaseTypesHandler());
// XMLSchema List handling
$h->registerSubscribingHandler(new XmlSchemaDateHandler());
// XMLSchema date handling
});
$this->serializer = $serializerBuilder->build();
}
/**
* RPC url action
*
* @param $bundle
* @param $service
* @param $method
* @param Request $request
*
* @Route("/{bundle}/{service}/{method}" , defaults={"_format": "json"})
* @Method("POST")
*
* @return Response
*/
public function rpcAction($bundle, $service, $method, Request $request)
{
$response = new Response();
$translator = $this->get('translator');
try {
$prefix = 'Hazu.Service';
$serviceObject = $this->get("{$prefix}.{$bundle}.{$service}");
if (true === method_exists($serviceObject, $method)) {
$params = json_decode($request->getContent(), true);
if (null === $params) {
throw new \Exception('$params não é um JSON valido');
}
$rService = $serviceObject->{$method}($params);
} else {
throw new \Exception($translator->trans('Metodo não encontrado'));
}
} catch (ServiceNotFoundException $e) {
$rService = new HazuException($e->getMessage());
$response->setStatusCode(500);
} catch (\Exception $e) {
$rService = new HazuException($e->getMessage());
$response->setStatusCode(500);
} finally {
$serializer = SerializerBuilder::create()->build();
$rJson = $serializer->serialize($rService, 'json', SerializationContext::create()->enableMaxDepthChecks());
$response->headers->set('x-hazu-type', gettype($rService));
if (gettype($rService) == 'object') {
$response->headers->set('x-hazu-class', get_class($rService));
}
$response->setContent($rJson);
}
return $response;
}
protected function setUp()
{
parent::setUp();
$this->serializer = SerializerBuilder::create()->build();
$this->validator = Validation::createValidator();
$this->action->setSerializer($this->serializer)->setValidator($this->validator);
}
/**
* @return \JMS\Serializer\Serializer
*/
private function serializer()
{
if (null === $this->serializer) {
$this->serializer = SerializerBuilder::create()->addMetadataDir(__DIR__ . '/../../Infrastructure/Application/Serialization/JMS/Config')->setCacheDir(__DIR__ . '/../../../var/cache/jms-serializer')->build();
}
return $this->serializer;
}
/**
* Test hydrate single entity
*/
public function testHydrateEntity()
{
$serializer = SerializerBuilder::create()->build();
$service = new HydratorService($serializer, $this->getTransformer());
$result = $service->hydrateEntity(json_encode($this->testData), 'MJanssen\\Assets\\Entity\\Test');
$this->assertEquals($this->createEntity($this->testData), $result);
}
/**
* @param string $username
* @param string $apiKey
*/
public function __construct($username, $apiKey)
{
$this->username = $username;
$this->apiKey = $apiKey;
$this->serializer = SerializerBuilder::create()->setCacheDir(__DIR__ . '/../../../cache')->setDebug(true)->build();
$this->client = new Client(new SerializerWrapper($this->serializer));
}
/**
* Instantiate a SerpPageSerializer
* @param string $cacheDir
*/
public function __construct($cacheDir = self::DEFAULT_SERIALIZER_CACHE_DIR)
{
if (!SerpPageSerializerHelper::validateDir($cacheDir)) {
throw new \Franzip\SerpPageSerializer\Exceptions\InvalidArgumentException('Invalid SerpPageSerializer $cacheDir: please supply a valid non-empty string.');
}
$this->serializer = SerializerBuilder::create()->setCacheDir($cacheDir)->build();
}
public function editAction(Request $request, $id)
{
$serializer = SerializerBuilder::create()->build();
$data = array('success' => false, 'error' => 'Ошибка обновления книги');
if ($request->getMethod() == 'POST') {
$requestData = $request->request->all();
if (empty($requestData['apiKey']) || !$this->checkApiKey($requestData['apiKey'])) {
$data['error'] = 'Неверный ключ';
$jsonContent = $serializer->serialize($data, 'json');
return new Response($jsonContent);
}
$book = $this->getDoctrine()->getManager()->getRepository('IntaroBookStoreBundle:Book')->find($id);
if (!$book) {
$data['error'] = 'Книга не найдена';
$jsonContent = $serializer->serialize($data, 'json');
return new Response($jsonContent);
}
if (!empty($requestData['name']) && !empty($requestData['author']) && !empty($requestData['readingDate']) && isset($requestData['download'])) {
$book->setName($requestData['name']);
$book->setAuthor($requestData['author']);
$book->setReadingDate(new \DateTime($requestData['readingDate']));
$book->setDownload($requestData['download']);
} else {
$data['error'] = 'Заданы не все необходимые поля';
$jsonContent = $serializer->serialize($data, 'json');
return new Response($jsonContent);
}
$em = $this->getDoctrine()->getManager();
$em->persist($book);
$em->flush();
$data = array('success' => true, 'message' => 'Книга успешно обновлена');
}
$jsonContent = $serializer->serialize($data, 'json');
return new Response($jsonContent);
}
/**
* @return mixed
*/
public static function getSerializer()
{
if (!self::$serializer) {
self::$serializer = SerializerBuilder::create()->build();
}
return self::$serializer;
}
private function getSerializer()
{
if (is_null($this->serializer)) {
$this->serializer = SerializerBuilder::create()->addMetadataDir(dirname(__DIR__) . '/V1_1_1/Metadata/Cdm', 'CdmFr\\Model\\V1_1_1\\Cdm')->addMetadataDir(dirname(__DIR__) . '/V1_1_1/Metadata/CdmFr', 'CdmFr\\Model\\V1_1_1\\CdmFr')->addMetadataDir(dirname(__DIR__) . '/V1_1_1/Metadata/Lheo', 'CdmFr\\Model\\V1_1_1\\Lheo')->build();
}
return $this->serializer;
}
/**
* Set up all the mocks and the serializer class
*
* @return void
*/
public function setUp()
{
$this->serializer = SerializerBuilder::create()->build();
$this->setupPheanstalkConnectionMock();
$this->generateFakeParams();
$this->setupEntityManagerMock();
}
public function __construct(array $config)
{
$config = array_replace($defaults = ['subscribers' => [], 'listeners' => [], 'extraHandlers' => []], $config);
$serializerBuilder = SerializerBuilder::create();
if (isset($config['cacheDir'])) {
$serializerBuilder->setCacheDir($config['cacheDir']);
}
if (isset($config['propertyNamingStrategy'])) {
$serializerBuilder->setPropertyNamingStrategy($config['propertyNamingStrategy']);
}
if (isset($config['objectConstructor'])) {
$serializerBuilder->setObjectConstructor($config['objectConstructor']);
}
if (isset($config['debug'])) {
$serializerBuilder->setDebug((bool) $config['objectConstructor']);
}
$serializerBuilder->addDefaultHandlers();
$extraHandlers = $config['extraHandlers'];
$serializerBuilder->configureHandlers(function (HandlerRegistry $handlerRegistry) use($extraHandlers) {
array_walk($extraHandlers, [$handlerRegistry, 'registerSubscribingHandler']);
});
$subscribers = $config['subscribers'];
$listeners = $config['listeners'];
$serializerBuilder->configureListeners(function (EventDispatcher $dispatcher) use($subscribers, $listeners) {
array_walk($subscribers, [$dispatcher, 'addSubscriber']);
foreach ($listeners as $event => $callables) {
foreach ($callables as $cb) {
$dispatcher->addListener($event, $cb);
}
}
});
$this->serializer = $serializerBuilder->build();
}
/**
* @param string $key
* @param mixed $value
*/
public function store($key, $value)
{
$serializer = SerializerBuilder::create()->build();
$jsonContent = $serializer->serialize($value, 'json');
apc_store($this->getCacheKey() . $key, $jsonContent);
$this->cacheDriver->store($this->getCacheKey() . $key, $jsonContent);
}
public function register()
{
\Doctrine\Common\Annotations\AnnotationRegistry::registerLoader('class_exists');
$this->app->singleton('serializer', function ($app) {
return SerializerBuilder::create()->setObjectConstructor(new DoctrineObjectConstructor($app->make('registry'), new UnserializeObjectConstructor()))->build();
});
}
/**
* Constructor
*
* By Default if a JMS Serializer isn't provided, one will be created.
* Providing a JMS Serializer instance allows for additional event handling,
* caching and extensions to be loaded
*
* @param Serializer $serializer
*/
public function __construct(Serializer $serializer = null)
{
if (is_null($serializer)) {
$serializer = SerializerBuilder::create()->build();
}
$this->serializer = $serializer;
}
protected function toXml($oObject)
{
$oSerializer = SerializerBuilder::create()->build();
$sXml = $oSerializer->serialize($oObject, 'xml');
$this->_sXml = $sXml;
return $this;
}
/**
* MxToolbox constructor.
* @param ApiToken|null $apiToken
* @param $secure
*/
public function __construct(ApiToken $apiToken, bool $secure = true)
{
$this->apiToken = $apiToken;
$this->httpClient = new Client(['base_uri' => $this->getURL($secure), 'headers' => ['Authorization' => $this->apiToken->get()]]);
$this->buildAnnotationRegistry();
$this->serializer = $serializer = SerializerBuilder::create()->build();
}
/**
* Registers services on the given app.
*
* This method should only be used to configure services and parameters.
* It should not get services.
*
* @param Application $app
*/
public function register(Application $app)
{
$app['serializer.metadata_dirs'] = [];
$app['serializer.stopwatch_subscriber'] = $app->share(function () use($app) {
return new StopwatchEventSubscriber($app['stopwatch']);
});
$app['serializer.doctrine_object_deserialize_listener'] = $app->share(function () use($app) {
return new DoctrineObjectDeserializeListener($app['doctrine']);
});
$app['serializer.builder'] = $app->share(function () use($app) {
$builder = SerializerBuilder::create();
$builder->setDebug($app['debug']);
$builder->setObjectConstructor(new DoctrineObjectConstructor($app['doctrine'], new UnserializeObjectConstructor()));
if (isset($app['serializer.cache_dir'])) {
$builder->setCacheDir($app['serializer.cache_dir']);
}
if (isset($app['serializer.metadata_dirs'])) {
$builder->setMetadataDirs($app['serializer.metadata_dirs']);
}
$builder->configureListeners(function (EventDispatcher $dispatcher) use($app) {
$dispatcher->addSubscriber($app['serializer.doctrine_object_deserialize_listener']);
});
if (isset($app['stopwatch'])) {
$builder->configureListeners(function (EventDispatcher $dispatcher) use($app) {
$dispatcher->addSubscriber($app['serializer.stopwatch_subscriber']);
});
}
return $builder;
});
$app['serializer'] = $app->share(function () use($app) {
return $app['serializer.builder']->build();
});
}
/**
* Exclusion strategy by JMS group name
*
* @author Huong Le <*****@*****.**>
*
* @param Entity|Collection $data Entity or array collection of entity
* @param string $JMSGroup Name of JMS group
*
* @return array Array after the exclusion was done
*/
public function getFinalResultByJMSGroup($data, $JMSGroup)
{
$serializer = SerializerBuilder::create()->build();
$json = $serializer->serialize($data, 'json', SerializationContext::create()->setGroups([$JMSGroup])->setSerializeNull(true)->enableMaxDepthChecks());
$arr = json_decode($json, true);
return $arr;
}
public function testSerialization()
{
$element1 = new ProductImage('MOB_12543');
$element1->add(new ImageUri('http://host.com/img1.jpg'));
$element2 = new ProductImage('ASM_A8012');
$element2->add(new ImageUri('http://host.com/img2.jpg'));
$collection = new ProductImageCollection();
$collection->add($element1);
$collection->add($element2);
\SellerCenter\SDK\Common\AnnotationRegistry::registerAutoloadNamespace();
$serializer = \JMS\Serializer\SerializerBuilder::create()->build();
$xml = '
<Request>
<ProductImage>
<SellerSku>MOB_12543</SellerSku>
<Images>
<Image>http://host.com/img1.jpg</Image>
</Images>
</ProductImage>
<ProductImage>
<SellerSku>ASM_A8012</SellerSku>
<Images>
<Image>http://host.com/img2.jpg</Image>
</Images>
</ProductImage>
</Request>
';
$this->assertXmlStringEqualsXmlString($xml, $serializer->serialize($collection, 'xml'));
}
public function testDeserialization()
{
$serializer = SerializerBuilder::create()->build();
$serialized = file_get_contents(__DIR__ . '/../mock/GetAllDomainsResponse.xml');
$responseObj = $serializer->deserialize($serialized, 'SMH\\Enom\\Response\\BaseResponse', 'xml');
$this->assertInstanceOf('SMH\\Enom\\Response\\GetAllDomainsResponse', $responseObj);
$collection = $responseObj->getAllDomains;
$this->assertCount(2, $collection);
$domain1 = $collection[0];
$this->assertEquals('sesame.com', $domain1->domainName);
$this->assertEquals('0000000001', $domain1->domainNameId);
$this->assertInstanceOf('\\DateTime', $domain1->expiration);
$this->assertEquals('2016-01-28T22:19:26+00:00', $domain1->expiration->format(\DateTime::ATOM));
$this->assertEquals('Locked', $domain1->lockStatus);
$this->assertEquals('No', $domain1->autoRenew);
$this->assertTrue($domain1->isLocked());
$this->assertFalse($domain1->isAutoRenew());
$domain2 = $collection[1];
$this->assertEquals('sesameexample.com', $domain2->domainName);
$this->assertEquals('0000000002', $domain2->domainNameId);
$this->assertInstanceOf('\\DateTime', $domain2->expiration);
$this->assertEquals('2016-03-11T16:10:07+00:00', $domain2->expiration->format(\DateTime::ATOM));
$this->assertEquals('Not Locked', $domain2->lockStatus);
$this->assertEquals('Yes', $domain2->autoRenew);
$this->assertFalse($domain2->isLocked());
$this->assertTrue($domain2->isAutoRenew());
}
/**
* @param mixed $value
* @return $this
*/
public function set($value)
{
$serializer = SerializerBuilder::create()->build();
$jsonContent = $serializer->serialize($value, 'json');
$this->value = $jsonContent;
return $this;
}
/**
* Usado para fazer um lazy load do serializer.
* Ele vai pegar a configuração prévia do builder e criar um
* serializer novo com elas.
*
* @return Serializer
*/
protected function getSerializer()
{
if (null === $this->serializer) {
$this->serializer = $this->serializerBuilder->build();
}
return $this->serializer;
}
public function getFakedApiResponse($class)
{
AnnotationRegistry::registerLoader('class_exists');
$serializer = SerializerBuilder::create()->build();
$response = new $class();
return $serializer->serialize($response, 'json');
}
public function testDeserialization()
{
$serializer = SerializerBuilder::create()->build();
$serialized = file_get_contents(__DIR__ . '/../mock/SetHostsResponse.xml');
$responseObj = $serializer->deserialize($serialized, 'SMH\\Enom\\Response\\BaseResponse', 'xml');
$this->assertInstanceOf('SMH\\Enom\\Response\\SetHostsResponse', $responseObj);
}
