/**
* Execute after types are built.
*/
public function postBuild()
{
$types_build_path = $this->getBuildPath() ? "{$this->getBuildPath()}/types.php" : null;
if ($types_build_path) {
$result = [];
$result[] = '<?php';
$result[] = '';
if ($this->getStructure()->getConfig('header_comment')) {
$result = array_merge($result, explode("\n", $this->getStructure()->getConfig('header_comment')));
$result[] = '';
}
$namespace = $this->getStructure()->getNamespace();
if ($namespace) {
$namespace = ltrim($namespace, '\\');
}
if ($this->getStructure()->getNamespace()) {
$result[] = '/**';
$result[] = ' * @package ' . $this->getStructure()->getNamespace();
$result[] = ' */';
}
$result[] = 'return [';
foreach ($this->getStructure()->getTypes() as $current_type) {
$result[] = ' ' . var_export($namespace . '\\' . Inflector::classify(Inflector::singularize($current_type->getName())), true) . ',';
}
$result[] = '];';
$result[] = '';
$result = implode("\n", $result);
if (is_file($types_build_path) && file_get_contents($types_build_path) === $result) {
return;
} else {
file_put_contents($types_build_path, $result);
$this->triggerEvent('on_types_built', [$types_build_path]);
}
}
}
/**
* {@inheritdoc}
*/
public function camelize($str)
{
if (isset($this->rules['camelize'][$str])) {
return $this->rules['camelize'][$str];
}
return DoctrineInflector::classify($str);
}
public function validate(Request $request, array $rules)
{
$valid = true;
foreach ($rules as $field => $rule) {
if (is_null($rule) || !is_string($rule) || strlen($rule) == 0) {
throw new ValidationException("Rule must be a string");
}
// get field value
$value = $request->input($field);
// split validation rule into required / sometimes (no validation if not set or empty)
// contract and contract parameters
$parts = explode("|", $rule);
if (is_null($parts) || !is_array($parts) || count($parts) < 3) {
throw new ValidationException("Invalid rule");
}
$required = strtolower($parts[0]) == "required" ? true : false;
if ($required && is_null($value)) {
$valid = false;
continue;
}
$args = explode(":", $parts[1]);
$clazz = Inflector::classify($args[0]) . "Contract";
if (!class_exists($clazz)) {
throw new ValidationException("Invalid rule: invalid validation class '{$clazz}'");
}
$instance = new $clazz($value, isset($args[1]) ? $args[1] : array());
if (!$instance instanceof Contract) {
throw new ValidationException("Invalid rule: invalid validation class '{$clazz}'. Class must extend Simplified\\Validator\\Contract");
}
if (!$instance->isValid()) {
$valid = false;
}
}
return $valid;
}
/**
* {@inheritDoc}
*/
public function process(ContainerBuilder $container)
{
if (!$container->hasDefinition(self::SERVICE_KEY)) {
return;
}
// find providers
$providers = [];
$taggedServices = $container->findTaggedServiceIds(self::TAG);
foreach ($taggedServices as $id => $attributes) {
if (empty($attributes[0]['scope'])) {
throw new InvalidConfigurationException(sprintf('Tag attribute "scope" is required for "%s" service', $id));
}
$priority = isset($attributes[0]['priority']) ? $attributes[0]['priority'] : 0;
$scope = $attributes[0]['scope'];
$providers[$scope][$priority][] = new Reference($id);
}
if (empty($providers)) {
return;
}
// add to chain
$serviceDef = $container->getDefinition(self::SERVICE_KEY);
foreach ($providers as $scope => $items) {
// sort by priority and flatten
krsort($items);
$items = call_user_func_array('array_merge', $items);
// register
foreach ($items as $provider) {
$serviceDef->addMethodCall(sprintf('add%sVariablesProvider', Inflector::classify($scope)), [$provider]);
}
}
}
/**
* @param $keys
* @param $object
* @return array
*/
protected function getParametersFromObject($keys, $object)
{
$parameters = [];
foreach ($keys as $key) {
$relation = $object;
$method = 'get' . Inflector::classify($key);
if (method_exists($relation, $method)) {
$relation = $relation->{$method}();
} else {
$segments = explode('_', $key);
if (count($segments) > 1) {
foreach ($segments as $segment) {
$method = 'get' . Inflector::classify($segment);
if (method_exists($relation, $method)) {
$relation = $relation->{$method}();
} else {
$relation = $object;
break;
}
}
}
}
if ($object !== $relation) {
$parameters[$key] = $relation;
}
}
return $parameters;
}
/**
* @param TypeInterface $type
*/
public function buildType(TypeInterface $type)
{
$class_name = Inflector::classify(Inflector::singularize($type->getName()));
$base_class_name = 'Base\\' . $class_name;
$class_build_path = $this->getBuildPath() ? "{$this->getBuildPath()}/{$class_name}.php" : null;
if ($class_build_path && is_file($class_build_path)) {
$this->triggerEvent('on_class_build_skipped', [$class_name, $class_build_path]);
return;
}
$result = [];
$result[] = '<?php';
$result[] = '';
if ($this->getStructure()->getConfig('header_comment')) {
$result = array_merge($result, explode("\n", $this->getStructure()->getConfig('header_comment')));
$result[] = '';
}
if ($this->getStructure()->getNamespace()) {
$result[] = 'namespace ' . $this->getStructure()->getNamespace() . ';';
$result[] = '';
$result[] = '/**';
$result[] = ' * @package ' . $this->getStructure()->getNamespace();
$result[] = ' */';
}
$result[] = 'class ' . $class_name . ' extends ' . $base_class_name;
$result[] = '{';
$result[] = '}';
$result[] = '';
$result = implode("\n", $result);
if ($this->getBuildPath()) {
file_put_contents($class_build_path, $result);
} else {
eval(ltrim($result, '<?php'));
}
$this->triggerEvent('on_class_built', [$class_name, $class_build_path]);
}
/**
* Catch all getter and setter
*
* @param string $name
* @param array $arguments
*
* @return mixed
*/
public function __call($name, $arguments)
{
// Match the getters
if (substr($name, 0, 3) == 'get') {
$parameter = Inflector::tableize(substr($name, 3));
if (property_exists($this, $parameter)) {
return $this->{$parameter};
} else {
throw new \Exception(sprintf('The property "%s" does not exist.', $parameter));
}
}
// Match the setters
if (substr($name, 0, 3) == 'set') {
$parameter = Inflector::tableize(substr($name, 3));
$method = 'set' . Inflector::classify($parameter);
if (method_exists($this, $method)) {
return $this->{$method}($arguments[0]);
} else {
if (property_exists($this, $parameter) && isset($arguments[0])) {
$this->{$parameter} = $arguments[0];
return $this;
} else {
throw new \Exception(sprintf('The property "%s" does not exist.', $parameter));
}
}
}
}
/**
* {@inheritdoc}
*/
public function getDirection($activity, $target)
{
//check if target is entity created from admin part
if (!$target instanceof EmailHolderInterface) {
$metadata = $this->doctrineHelper->getEntityMetadata($target);
$columns = $metadata->getColumnNames();
$className = get_class($target);
foreach ($columns as $column) {
//check only columns with 'contact_information'
if ($this->isEmailType($className, $column)) {
$getMethodName = "get" . Inflector::classify($column);
/** @var $activity Email */
if ($activity->getFromEmailAddress()->getEmail() === $target->{$getMethodName}()) {
return DirectionProviderInterface::DIRECTION_OUTGOING;
} else {
foreach ($activity->getTo() as $recipient) {
if ($recipient->getEmailAddress()->getEmail() === $target->{$getMethodName}()) {
return DirectionProviderInterface::DIRECTION_INCOMING;
}
}
}
}
}
return DirectionProviderInterface::DIRECTION_UNKNOWN;
}
/** @var $activity Email */
/** @var $target EmailHolderInterface */
if ($activity->getFromEmailAddress()->getEmail() === $target->getEmail()) {
return DirectionProviderInterface::DIRECTION_OUTGOING;
}
return DirectionProviderInterface::DIRECTION_INCOMING;
}
/**
* @param Request $request
* @param string $id
* @param string $type
* @param string $event
* @param string $eventClass
*
* @return Response
*/
protected function reverseTransform(Request $request, $id, $type, $event, $eventClass)
{
$facadeName = Inflector::classify($type) . 'Facade';
$typeName = Inflector::tableize($type);
$format = $request->get('_format', 'json');
$facade = $this->get('jms_serializer')->deserialize($request->getContent(), 'OpenOrchestra\\ApiBundle\\Facade\\' . $facadeName, $format);
$mixed = $this->get('open_orchestra_model.repository.' . $typeName)->find($id);
$oldStatus = null;
if ($mixed instanceof StatusableInterface) {
$oldStatus = $mixed->getStatus();
}
$mixed = $this->get('open_orchestra_api.transformer_manager')->get($typeName)->reverseTransform($facade, $mixed);
if ($this->isValid($mixed)) {
$em = $this->get('object_manager');
$em->persist($mixed);
$em->flush();
if (in_array('OpenOrchestra\\ModelInterface\\Event\\EventTrait\\EventStatusableInterface', class_implements($eventClass))) {
$this->dispatchEvent($event, new $eventClass($mixed, $oldStatus));
return array();
}
$this->dispatchEvent($event, new $eventClass($mixed));
return array();
}
return $this->getViolations();
}
public function addTest($testName)
{
$methodName = 'test' . Inflector::classify($testName);
$testMethod = new ClassMethod($methodName, array(), array());
$testMethod->setScope('public');
$this->methods[] = $testMethod;
return $testMethod;
}
/**
* Create platform function node.
*
* @param string $platformName
* @param string $functionName
* @param array $parameters
* @throws \Doctrine\ORM\Query\QueryException
* @return PlatformFunctionNode
*/
public static function create($platformName, $functionName, array $parameters)
{
$className = __NAMESPACE__ . '\\Platform\\Functions\\' . Inflector::classify(strtolower($platformName)) . '\\' . Inflector::classify(strtolower($functionName));
if (!class_exists($className)) {
throw QueryException::syntaxError(sprintf('Function "%s" does not supported for platform "%s"', $functionName, $platformName));
}
return new $className($parameters);
}
/**
* Parse a response body into a collection
*
* @param string $data
*
* @return ResultCollection
*/
public static function parseResult($data)
{
$responseBody = json_decode($data, true);
$rootKey = self::getRootKey($responseBody);
$data = self::getResultForRootKey($responseBody, $rootKey);
$className = Inflector::classify($rootKey);
$result = new Result();
return $result->fromArrayWithObject($data, $className);
}
public function instantiate(string $class, array $data)
{
$object = new $class();
foreach ($data as $key => $value) {
$method = 'set' . Inflector::classify($key);
$object->{$method}($value);
}
return $object;
}
public function getHandler($alias)
{
$className = Inflector::classify($alias);
$handlerClass = sprintf('\\%s\\%sHandler', $this->handlerNamespace, $className);
if (!class_exists($handlerClass)) {
throw new \RuntimeException('The specified handler class does not exist: ' . $handlerClass);
}
return new $handlerClass($this->typeHandler);
}
/**
* @param string $controller
* @return string
*/
public static function getActionClassFromControllerName($controller)
{
$actionNameStart = strpos($controller, ':') + 1;
$actionNameLength = strrpos($controller, 'Action') - $actionNameStart;
$actionName = substr($controller, $actionNameStart, $actionNameLength);
$actionName = Inflector::classify($actionName);
$refl = new \ReflectionClass(Action::class);
return $refl->getNamespaceName() . '\\' . $actionName;
}
/**
* @param string $module
* @return string
*/
public function guessClass($module)
{
$module = str_replace('/', '\\', $module);
$module = explode('\\', $module);
array_walk($module, function (&$chunk) {
$chunk = Inflector::classify($chunk);
});
return join('\\', $module) . 'Module';
}
/**
* Resolve default setter/getter names
*
* @param string $property
* @param string $getter
* @param string $setter
* @return string[]
*/
protected static function resolveFunctionNames($property, $getter = null, $setter = null)
{
if (!$getter) {
$getter = 'get' . Inflector::classify($property);
}
if (!$setter) {
$setter = 'set' . Inflector::classify($property);
}
return [$getter, $setter];
}
/**
* @param TypeInterface $type
*/
public function buildType(TypeInterface $type)
{
$base_manager_class_name = Inflector::classify($type->getName());
$type_class_name = Inflector::classify(Inflector::singularize($type->getName()));
$base_class_build_path = $this->getBuildPath() ? "{$this->getBuildPath()}/Manager/Base/{$base_manager_class_name}.php" : null;
$result = [];
$result[] = '<?php';
$result[] = '';
if ($this->getStructure()->getConfig('header_comment')) {
$result = array_merge($result, explode("\n", $this->getStructure()->getConfig('header_comment')));
$result[] = '';
}
if ($this->getStructure()->getNamespace()) {
$base_class_namespace = $this->getStructure()->getNamespace() . '\\Manager\\Base';
$type_class_name = '\\' . ltrim($this->getStructure()->getNamespace(), '\\') . '\\' . $type_class_name;
} else {
$base_class_namespace = 'Manager\\Base';
}
$result[] = 'namespace ' . $base_class_namespace . ';';
$result[] = '';
$result[] = '/**';
$result[] = ' * @package ' . $base_class_namespace;
$result[] = ' */';
$interfaces = $traits = [];
foreach ($type->getTraits() as $interface => $implementations) {
if ($interface != '--just-paste-trait--') {
$interfaces[] = '\\' . ltrim($interface, '\\');
}
if (count($implementations)) {
foreach ($implementations as $implementation) {
$traits[] = '\\' . ltrim($implementation, '\\');
}
}
}
$result[] = 'abstract class ' . $base_manager_class_name . ' extends \\ActiveCollab\\DatabaseObject\\Entity\\Manager';
$result[] = '{';
$result[] = ' /**';
$result[] = ' * Return type that this manager works with.';
$result[] = ' *';
$result[] = ' * @return string';
$result[] = ' */';
$result[] = ' public function getType()';
$result[] = ' {';
$result[] = ' return ' . var_export($type_class_name, true) . ';';
$result[] = ' }';
$result[] = '}';
$result[] = '';
$result = implode("\n", $result);
if ($this->getBuildPath()) {
file_put_contents($base_class_build_path, $result);
} else {
eval(ltrim($result, '<?php'));
}
$this->triggerEvent('on_class_built', [$base_manager_class_name, $base_class_build_path]);
}
protected function generateClass($group, $operations, $namespace, Context $context, $suffix = 'Resource')
{
$factory = new BuilderFactory();
$name = $group === 0 ? '' : $group;
$class = $factory->class(Inflector::classify($name . $suffix));
$class->extend('Resource');
foreach ($operations as $operation) {
$class->addStmt($this->operationGenerator->generate($this->operationNaming->generateFunctionName($operation), $operation, $context));
}
return $factory->namespace($namespace . "\\Resource")->addStmt($factory->use('Joli\\Jane\\Swagger\\Client\\QueryParam'))->addStmt($factory->use('Joli\\Jane\\Swagger\\Client\\Resource'))->addStmt($class)->getNode();
}
/**
* Set object properties.
*/
public function setObjectProperties($object, $properties)
{
foreach ($properties as $key => $value) {
$method = sprintf('set%s', Inflector::classify($key));
if (false === method_exists($object, $method)) {
continue;
}
$object->{$method}($value);
}
return $object;
}
/**
* {@inheritdoc}
*/
public function generateFromClassname($classname)
{
$bundles = $this->kernel->getBundles();
foreach ($bundles as $bundle) {
if (0 !== strpos($classname, $bundle->getNamespace())) {
continue;
}
$classname = sprintf('%s\\%s', Inflector::classify($bundle->getName()), trim(substr($classname, strlen($bundle->getNamespace())), '\\'));
}
return $this->generator->generateFromClassname($classname);
}
/**
* Set class name, name must not include default namespace and postfix.
*
* @param string $name
* @return $this
*/
public function setName($name)
{
if (strpos($name, '/') !== false || strpos($name, '\\') !== false) {
$name = str_replace('/', '\\', $name);
//Let's split namespace
$this->setNamespace(substr($name, 0, strrpos($name, '\\')));
$name = substr($name, strrpos($name, '\\') + 1);
}
$this->class->setName(Inflector::classify($name) . $this->options['postfix']);
return $this;
}
/**
* Find full class name using it's configured type and short name. Reaction will automatically
* add namespace and postfix. Method will return null if class can not be found.
*
* @param string $type
* @param string $name
* @return string|null
* @throws ReactorException
*/
public function findClass($type, $name)
{
if (!isset($this->config['generators'][$type])) {
throw new ReactorException("Undefined class type '{$type}'.");
}
$definition = $this->config['generators'][$type];
$class = $definition['namespace'] . '\\' . Inflector::classify($name) . $definition['postfix'];
if (!class_exists($class)) {
return null;
}
return $class;
}
/**
* Get a supported metric as a property.
*
* @param string $metric
* @return MetricInterface
*/
public function __get($metric)
{
if (empty($this->metrics[$metric])) {
$class_name = '\\ActiveCollab\\Insight\\AccountInsight\\Metric\\' . Inflector::classify($metric);
if (class_exists($class_name)) {
$this->metrics[$metric] = new $class_name($this, $this->insight, $this->connection, $this->log);
} else {
throw new LogicException("Metric '{$metric}' is not currently supported");
}
}
return $this->metrics[$metric];
}
/**
* @param string $element
* @param string $name
* @return string
*/
public function elementNamespace($element, $name = '')
{
$localNamespace = trim($this->elementOption($element, 'namespace', ''), '\\');
list($namespace, $name) = $this->splitName($name);
if (!empty($namespace)) {
$localNamespace .= '\\' . Inflector::classify($namespace);
}
if (empty($this->baseNamespace())) {
return $localNamespace;
}
return trim($this->baseNamespace() . '\\' . $localNamespace, '\\');
}
protected function getFieldMethods($model, $field_name)
{
$camelizedFieldName = Inflector::classify($field_name);
$methods = array('getters' => array("get{$camelizedFieldName}", "is{$camelizedFieldName}"), 'setters' => array("set{$camelizedFieldName}"));
foreach ($methods as $type => $type_methods) {
foreach ($type_methods as $i => $method) {
if (!method_exists($model, $method)) {
unset($methods[$type][$i]);
}
}
}
return $methods;
}
protected function resolveController($parameters)
{
if ($parameters['_route'] === 'magic') {
// Controller is not defined, magically resolve.
$controller = sprintf('Eng\\%s\\Controller\\%sController::%sAction', $this->bundle, Inflector::classify(strtolower($parameters['controller'])), Inflector::camelize(strtolower($parameters['action'])));
} else {
// Controller to use defined explicitly in route parameters
$controller = $parameters['_controller'];
}
list($controller, $action) = $this->createController($controller);
if (!method_exists($controller, $action)) {
throw new \InvalidArgumentException(sprintf('Method "%s::%s" does not exist.', get_class($controller), $action));
}
return array($controller, $action);
}
/**
* @param ApiResource $apiResource
*/
protected function addActions(ApiResource $apiResource)
{
$options = $this->getOptionsForApiResource($apiResource);
$def = $this->getDefinitionForApiResource($apiResource);
foreach ($this->getActionsForApiResource($apiResource) as $actionName) {
$class = Inflector::classify($actionName);
$actionClass = "BiteCodes\\RestApiGeneratorBundle\\Api\\Actions\\{$class}";
$action = new Definition($actionClass);
$action->addArgument(new Reference('router'));
$action->addMethodCall('setSecurityExpression', [$options['routes'][$actionName]['security']]);
$action->addMethodCall('setSerializationGroups', [$options['routes'][$actionName]['serialization_groups']]);
$this->container->set('bite_codes.rest_api_generator.action.' . $apiResource->getName() . '.' . Inflector::tableize($actionName), $action);
$def->addMethodCall('addAction', [$action]);
}
}
public function arrayToObject($hookData)
{
if (is_array($hookData) && count($hookData)) {
$hook = new Duration();
foreach ($hookData as $property => $value) {
// TODO: Research whether this is a security risk, e.g. if the property name has been injected via a REST post.
$method = 'set' . Inflector::classify($property);
if (($method == 'setStartDate' || $method == 'setEndDate') && !is_object($value) && !$value instanceof \DateTime) {
$value = new \DateTime($value, new \DateTimeZone($hookData['timezone']));
}
$hook->{$method}($value);
}
}
return $hook;
}
public function arrayToObject($hookData)
{
if (is_array($hookData) && count($hookData)) {
$hook = new Assignee();
foreach ($hookData as $property => $value) {
// TODO: Research whether this is a security risk, e.g. if the property name has been injected via a REST post.
$method = (string) 'set' . Inflector::classify($property);
if ($method == 'setUser' && !is_object($value)) {
$value = $this->em->getRepository('CampaignChainCoreBundle:User')->find($value);
}
$hook->{$method}($value);
}
}
return $hook;
}