/**
* Modifies the Request object to apply configuration information found in
* controllers annotations like the template to render or HTTP caching
* configuration.
*
* @param FilterControllerEvent $event A FilterControllerEvent instance
*/
public function onKernelController(FilterControllerEvent $event)
{
if (!is_array($controller = $event->getController())) {
return;
}
$className = class_exists('Doctrine\\Common\\Util\\ClassUtils') ? ClassUtils::getClass($controller[0]) : get_class($controller[0]);
$object = new \ReflectionClass($className);
$method = $object->getMethod($controller[1]);
$classConfigurations = $this->getConfigurations($this->reader->getClassAnnotations($object));
$methodConfigurations = $this->getConfigurations($this->reader->getMethodAnnotations($method));
$configurations = array();
foreach (array_merge(array_keys($classConfigurations), array_keys($methodConfigurations)) as $key) {
if (!array_key_exists($key, $classConfigurations)) {
$configurations[$key] = $methodConfigurations[$key];
} elseif (!array_key_exists($key, $methodConfigurations)) {
$configurations[$key] = $classConfigurations[$key];
} else {
if (is_array($classConfigurations[$key])) {
if (!is_array($methodConfigurations[$key])) {
throw new \UnexpectedValueException('Configurations should both be an array or both not be an array');
}
$configurations[$key] = array_merge($classConfigurations[$key], $methodConfigurations[$key]);
} else {
// method configuration overrides class configuration
$configurations[$key] = $methodConfigurations[$key];
}
}
}
$request = $event->getRequest();
foreach ($configurations as $key => $attributes) {
$request->attributes->set($key, $attributes);
}
}
/**
* {@inheritdoc}
*/
public function supports(PuliResource $resource)
{
if (false === $resource instanceof CmfResource) {
return false;
}
return $this->metadataFactory->hasMetadataFor(ClassUtils::getRealClass($resource->getPayloadType()));
}
/**
* Move element
*
* @param string $position
*/
public function moveAction($position)
{
$translator = $this->get('translator');
if (!$this->admin->isGranted('EDIT')) {
$this->addFlash('sonata_flash_error', $translator->trans('flash_error_no_rights_update_position'));
return new RedirectResponse($this->admin->generateUrl('list', $this->admin->getFilterParameters()));
}
$object = $this->admin->getSubject();
/** @var PositionHandler $positionService */
$positionService = $this->get('pix_sortable_behavior.position');
$entity = \Doctrine\Common\Util\ClassUtils::getClass($object);
$lastPosition = $positionService->getLastPosition($entity);
$position = $positionService->getPosition($object, $position, $lastPosition);
$setter = sprintf('set%s', ucfirst($positionService->getPositionFieldByEntity($entity)));
if (!method_exists($object, $setter)) {
throw new \LogicException(sprintf('%s does not implement ->%s() to set the desired position.', $object, $setter));
}
$object->{$setter}($position);
$this->admin->update($object);
if ($this->isXmlHttpRequest()) {
return $this->renderJson(array('result' => 'ok', 'objectId' => $this->admin->getNormalizedIdentifier($object)));
}
$this->addFlash('sonata_flash_success', $translator->trans('flash_success_position_updated'));
return new RedirectResponse($this->admin->generateUrl('list', array('filter' => $this->admin->getFilterParameters())));
}
/**
* {@inheritDoc}
*/
public function boot()
{
// Register an autoloader for proxies to avoid issues when unserializing them
// when the ORM is used.
if ($this->container->hasParameter('doctrine.orm.proxy_namespace')) {
$namespace = $this->container->getParameter('doctrine.orm.proxy_namespace');
$dir = $this->container->getParameter('doctrine.orm.proxy_dir');
$proxyGenerator = null;
if ($this->container->getParameter('doctrine.orm.auto_generate_proxy_classes')) {
// See https://github.com/symfony/symfony/pull/3419 for usage of references
$container =& $this->container;
$proxyGenerator = function ($proxyDir, $proxyNamespace, $class) use(&$container) {
$originalClassName = ClassUtils::getRealClass($class);
/** @var $registry Registry */
$registry = $container->get('doctrine');
// Tries to auto-generate the proxy file
/** @var $em \Doctrine\ORM\EntityManager */
foreach ($registry->getManagers() as $em) {
if (!$em->getConfiguration()->getAutoGenerateProxyClasses()) {
continue;
}
$metadataFactory = $em->getMetadataFactory();
if ($metadataFactory->isTransient($originalClassName)) {
continue;
}
$classMetadata = $metadataFactory->getMetadataFor($originalClassName);
$em->getProxyFactory()->generateProxyClasses(array($classMetadata));
clearstatcache(true, Autoloader::resolveFile($proxyDir, $proxyNamespace, $class));
break;
}
};
}
$this->autoloader = Autoloader::register($dir, $namespace, $proxyGenerator);
}
}
/**
* Checks if the entity can has notes
*
* @param object $entity
* @return bool
*/
public function isNoteAssociationEnabled($entity)
{
if (!is_object($entity) || !$this->doctrineHelper->isManageableEntity($entity) || $this->doctrineHelper->isNewEntity($entity)) {
return false;
}
return $this->noteAssociationHelper->isNoteAssociationEnabled(ClassUtils::getClass($entity));
}
/**
* Gets class name for the object, taking doctrine proxies into account.
*
* @param object $object The object.
*
* @return string The FQCN of the given object.
*/
public static function getClass($object)
{
if (class_exists('\\Doctrine\\Common\\Util\\ClassUtils')) {
return \Doctrine\Common\Util\ClassUtils::getClass($object);
}
return get_class($object);
}
/**
* {@inheritDoc}
*/
public function vote(TokenInterface $token, $object, array $attributes)
{
if (!$object || !is_object($object)) {
return self::ACCESS_ABSTAIN;
}
$objectClass = ClassUtils::getClass($object);
if (!$this->supportsClass($objectClass)) {
return self::ACCESS_ABSTAIN;
}
foreach ($attributes as $attribute) {
if (!$this->supportsAttribute($attribute)) {
return self::ACCESS_ABSTAIN;
}
}
$object = $this->convertToSupportedObject($object, $objectClass);
/** @var EmailUser[] $emailUsers */
$emailUsers = $object->getEmailUsers();
foreach ($attributes as $attribute) {
foreach ($emailUsers as $emailUser) {
if ($this->container->get('oro_security.security_facade')->isGranted($attribute, $emailUser)) {
return self::ACCESS_GRANTED;
}
if ($mailbox = $emailUser->getMailboxOwner() !== null && $token instanceof UsernamePasswordOrganizationToken) {
$repo = $this->container->get('doctrine')->getRepository('OroEmailBundle:Mailbox');
$mailboxes = $repo->findAvailableMailboxes($token->getUser(), $token->getOrganizationContext());
if (in_array($mailbox, $mailboxes)) {
return self::ACCESS_GRANTED;
}
}
}
}
return self::ACCESS_DENIED;
}
/**
* @param object $object
* @param int $depth
* @param bool $ignoreAcl
* @param Organization|null $organization
*
* @return Recipient[]
*/
public function getRecipients($object, $depth = 1, $ignoreAcl = false, Organization $organization = null)
{
$recipients = [];
if ($this->isAccessDenyForOrganization($object, $ignoreAcl, $organization)) {
return $recipients;
}
if (!$depth || ($ignoreAcl || !$this->securityFacade->isGranted('VIEW', $object))) {
if (!$depth || $this->securityFacade->getLoggedUser() !== $object) {
return $recipients;
}
}
$className = ClassUtils::getClass($object);
$metadata = $this->getMetadata($className);
$attributes = $this->initAttributes($className, $metadata);
foreach ($metadata->associationMappings as $name => $assoc) {
if (in_array('Oro\\Bundle\\EmailBundle\\Entity\\EmailInterface', class_implements($assoc['targetEntity']), true)) {
$attributes[] = new EmailAttribute($name, true);
} else {
if ($depth > 1) {
$assocObject = $this->getPropertyAccessor()->getValue($object, $name);
if (!$assocObject instanceof \Traversable && !is_array($assocObject)) {
if ($assocObject) {
$assocObject = [$assocObject];
} else {
$assocObject = [];
}
}
foreach ($assocObject as $obj) {
$recipients = array_merge($recipients, $this->getRecipients($obj, $depth - 1, false, $organization));
}
}
}
}
return array_merge($recipients, $this->createRecipientsFromEmails($this->createEmailsFromAttributes($attributes, $object), $object, $metadata));
}
/**
* @param $entity
*/
public function invalidateProcess($entity)
{
$handler = $this->getHandlerByClass(ClassUtils::getClass($entity));
if ($handler) {
$handler->invalidateProcess($entity);
}
}
/**
* @param OnFlushEventArgs $args
*/
public function onFlush(OnFlushEventArgs $args)
{
$this->initializeFromEventArgs($args);
$entities = array_merge($this->uow->getScheduledEntityInsertions(), $this->uow->getScheduledEntityDeletions(), $this->uow->getScheduledEntityUpdates());
/** @var Opportunity[] $entities */
$entities = array_filter($entities, function ($entity) {
return 'OroCRM\\Bundle\\SalesBundle\\Entity\\Opportunity' === ClassUtils::getClass($entity);
});
foreach ($entities as $entity) {
if (!$entity->getId() && $this->isValuable($entity)) {
// handle creation, just add to prev lifetime value and recalculate change set
$b2bCustomer = $entity->getCustomer();
$b2bCustomer->setLifetime($b2bCustomer->getLifetime() + $entity->getCloseRevenue());
$this->scheduleUpdate($b2bCustomer);
$this->uow->computeChangeSet($this->em->getClassMetadata(ClassUtils::getClass($b2bCustomer)), $b2bCustomer);
} elseif ($this->uow->isScheduledForDelete($entity) && $this->isValuable($entity)) {
$this->scheduleUpdate($entity->getCustomer());
} elseif ($this->uow->isScheduledForUpdate($entity)) {
// handle update
$changeSet = $this->uow->getEntityChangeSet($entity);
if ($this->isChangeSetValuable($changeSet)) {
if (!empty($changeSet['customer']) && $changeSet['customer'][0] instanceof B2bCustomer && B2bCustomerRepository::VALUABLE_STATUS === $this->getOldStatus($entity, $changeSet)) {
// handle change of b2b customer
$this->scheduleUpdate($changeSet['customer'][0]);
}
if ($this->isValuable($entity, isset($changeSet['closeRevenue'])) || B2bCustomerRepository::VALUABLE_STATUS === $this->getOldStatus($entity, $changeSet) && $entity->getCustomer()) {
$this->scheduleUpdate($entity->getCustomer());
}
}
}
}
}
/**
* Collect changes that were done
* Generates tags and store in protected variable
*
* @param OnFlushEventArgs $event
*/
public function onFlush(OnFlushEventArgs $event)
{
if (!$this->isApplicationInstalled) {
return;
}
$em = $event->getEntityManager();
$uow = $em->getUnitOfWork();
$entities = array_merge($uow->getScheduledEntityDeletions(), $uow->getScheduledEntityInsertions(), $uow->getScheduledEntityUpdates());
$collections = array_merge($uow->getScheduledCollectionUpdates(), $uow->getScheduledCollectionDeletions());
foreach ($collections as $collection) {
$owner = $collection->getOwner();
if (!in_array($owner, $entities, true)) {
$entities[] = $owner;
}
}
$generator = $this->sender->getGenerator();
foreach ($entities as $entity) {
if (!in_array(ClassUtils::getClass($entity), $this->skipTrackingFor)) {
// invalidate collection view pages only when entity has been added or removed
$includeCollectionTag = $uow->isScheduledForInsert($entity) || $uow->isScheduledForDelete($entity);
$this->collectedTags = array_merge($this->collectedTags, $generator->generate($entity, $includeCollectionTag));
}
}
$this->collectedTags = array_unique($this->collectedTags);
}
/**
* {@inheritdoc}
*/
public function name($objectOrClass)
{
$class = is_object($objectOrClass) ? ClassUtils::getClass($objectOrClass) : $objectOrClass;
if (!isset($this->names[$class])) {
$nsParts = array_map(function ($nsPart) {
return explode('_', StringsUtil::toUnderscore($nsPart));
}, explode('\\', $class));
$offset = array_search(['entity'], $nsParts);
if ($offset) {
$nsParts = array_slice($nsParts, $offset + 1);
}
$nsPartsCount = count($nsParts);
for ($i = 0; $i < $nsPartsCount - 1; $i++) {
if (array_intersect($nsParts[$i], $nsParts[$i + 1]) === $nsParts[$i]) {
unset($nsParts[$i]);
}
}
$parts = [];
foreach ($nsParts as $nsPart) {
$parts = array_merge($parts, $nsPart);
}
$this->names[$class] = implode('_', $parts);
}
return $this->names[$class];
}
/**
* Checks if the entity can have comments
*
* @param object|null $entity
*
* @return bool
*/
public function isApplicable($entity)
{
if (!is_object($entity) || !$this->doctrineHelper->isManageableEntity($entity) || !$this->securityFacade->isGranted('oro_comment_view')) {
return false;
}
return $this->commentAssociationHelper->isCommentAssociationEnabled(ClassUtils::getClass($entity));
}
/**
* Returns DELETE query builder with conditions for deleting from snapshot table by entity
*
* @param array $entities
* @throws \InvalidArgumentException
* @return QueryBuilder|null
*/
protected function getSnapshotDeleteQueryBuilderByEntities(array $entities)
{
if (empty($entities)) {
throw new \InvalidArgumentException('List of entity can not be empty');
}
$deleteParams = array();
$entityManager = $this->getEntityManager();
$segmentQB = $entityManager->createQueryBuilder();
$segmentQB->select('s.id, s.entity')->from('OroSegmentBundle:Segment', 's');
foreach ($entities as $key => $entity) {
if (is_array($entity) && array_key_exists('id', $entity)) {
$entityId = $entity['id'];
$className = ClassUtils::getClass($entity['entity']);
} else {
/** @var object $entity */
$className = ClassUtils::getClass($entity);
$metadata = $entityManager->getClassMetadata($className);
$entityIds = $metadata->getIdentifierValues($entity);
$entityId = reset($entityIds);
}
if (!$entityId) {
continue;
}
if (!isset($deleteParams[$className])) {
$segmentQB->orWhere('s.entity = :className' . $key)->setParameter('className' . $key, $className);
}
$deleteParams[$className]['entityIds'][] = (string) $entityId;
}
$segments = $segmentQB->getQuery()->getResult();
foreach ($segments as $segment) {
$deleteParams[$segment['entity']]['segmentIds'][] = (string) $segment['id'];
}
return $this->getDeleteQueryBuilderByParameters($deleteParams);
}
/**
* {@inheritdoc}
*/
public function buildCacheEntry(ClassMetadata $metadata, EntityCacheKey $key, $entity)
{
$data = $this->uow->getOriginalEntityData($entity);
$data = array_merge($data, $key->identifier);
// why update has no identifier values ?
foreach ($metadata->associationMappings as $name => $assoc) {
if (!isset($data[$name])) {
continue;
}
if (!isset($assoc['cache']) || !($assoc['type'] & ClassMetadata::TO_ONE)) {
unset($data[$name]);
continue;
}
if (!isset($assoc['id'])) {
$targetClass = ClassUtils::getClass($data[$name]);
$targetId = $this->uow->getEntityIdentifier($data[$name]);
$data[$name] = new AssociationCacheEntry($targetClass, $targetId);
continue;
}
// handle association identifier
$targetId = is_object($data[$name]) && $this->uow->isInIdentityMap($data[$name]) ? $this->uow->getEntityIdentifier($data[$name]) : $data[$name];
// @TODO - fix it !
// handle UnitOfWork#createEntity hash generation
if (!is_array($targetId)) {
$data[reset($assoc['joinColumnFieldNames'])] = $targetId;
$targetEntity = $this->em->getClassMetadata($assoc['targetEntity']);
$targetId = array($targetEntity->identifier[0] => $targetId);
}
$data[$name] = new AssociationCacheEntry($assoc['targetEntity'], $targetId);
}
return new EntityCacheEntry($metadata->name, $data);
}
/**
* Check object status is enity
*
* @param object|string $entity
* @return bool
*/
protected function isEntity($entity)
{
if (is_object($entity)) {
$entity = ClassUtils::getClass($entity);
}
return !$this->entityManager->getMetadataFactory()->isTransient($entity);
}
/**
* Modifies the Request object to apply configuration information found in
* controllers annotations like the template to render or HTTP caching
* configuration.
*
* @param FilterControllerEvent $event A FilterControllerEvent instance
*
* @return void
*/
public function onKernelController(FilterControllerEvent $event)
{
if (!is_array($controller = $event->getController())) {
return;
}
$className = class_exists('Doctrine\\Common\\Util\\ClassUtils') ? ClassUtils::getClass($controller[0]) : get_class($controller[0]);
$object = new \ReflectionClass($className);
$transactional = $this->reader->getClassAnnotation($object, Transactional::NAME);
if (!$transactional instanceof Transactional) {
return;
}
$avoidTransaction = $this->reader->getMethodAnnotation($object->getMethod($controller[1]), AvoidTransaction::NAME);
if (!is_null($avoidTransaction)) {
return;
}
$request = $event->getRequest();
$modelName = $transactional->model;
$model = new $modelName();
$this->transactionBuilder->setRequestMethod($request->getRealMethod());
$this->transactionBuilder->setRequestSource(Transaction::SOURCE_REST);
$this->transactionBuilder->setRelatedRoute($transactional->relatedRoute);
$ids = [];
foreach ($model->getIds() as $field => $value) {
$ids[$field] = $request->attributes->get($field);
}
$this->transactionBuilder->setRelatedIds($ids);
$this->transactionBuilder->setModel($transactional->model);
$transaction = $this->transactionBuilder->build();
$request->attributes->set('transaction', $transaction);
}
/**
* Add owner field to forms
*
* @param BeforeFormRenderEvent $event
*/
public function addOwnerField(BeforeFormRenderEvent $event)
{
$environment = $event->getTwigEnvironment();
$data = $event->getFormData();
$form = $event->getForm();
$label = false;
$entityProvider = $this->configManager->getProvider('entity');
if (is_object($form->vars['value'])) {
$className = ClassUtils::getClass($form->vars['value']);
if (class_exists($className) && $entityProvider->hasConfig($className, 'owner')) {
$config = $entityProvider->getConfig($className, 'owner');
$label = $config->get('label');
}
}
$ownerField = $environment->render("OroOrganizationBundle::owner.html.twig", array('form' => $form, 'label' => $label));
/**
* Setting owner field as first field in first data block
*/
if (!empty($data['dataBlocks'])) {
if (isset($data['dataBlocks'][0]['subblocks'])) {
if (!isset($data['dataBlocks'][0]['subblocks'][0])) {
$data['dataBlocks'][0]['subblocks'][0] = ['data' => []];
}
array_unshift($data['dataBlocks'][0]['subblocks'][0]['data'], $ownerField);
}
}
$event->setFormData($data);
}
/**
* Get the last available version for the provided document
*
* @param VersionableInterface $versionable
*
* @return Version|null
*/
protected function getPreviousVersion(VersionableInterface $versionable)
{
$resourceName = ClassUtils::getClass($versionable);
$resourceId = $versionable->getId();
$version = $this->documentManager->createQueryBuilder($this->versionClass)->field('resourceName')->equals($resourceName)->field('resourceId')->equals($resourceId)->limit(1)->sort('loggedAt', 'desc')->getQuery()->getSingleResult();
return $version;
}
/**
* Returns the context for the given activity class and id
*
* @param string $class The FQCN of the activity entity
* @param $id
*
* @return array
*/
public function getActivityContext($class, $id)
{
$currentUser = $this->securityTokenStorage->getToken()->getUser();
$userClass = ClassUtils::getClass($currentUser);
$entity = $this->doctrineHelper->getEntity($class, $id);
$result = [];
if (!$entity || !$entity instanceof ActivityInterface) {
return $result;
}
$targets = $entity->getActivityTargetEntities();
$entityProvider = $this->configManager->getProvider('entity');
foreach ($targets as $target) {
$targetClass = ClassUtils::getClass($target);
$targetId = $target->getId();
if ($userClass === $targetClass && $currentUser->getId() === $targetId) {
continue;
}
$item = [];
$config = $entityProvider->getConfig($targetClass);
$safeClassName = $this->entityClassNameHelper->getUrlSafeClassName($targetClass);
$item = $this->prepareItemTitle($item, $targetClass, $target, $targetId);
$item['activityClassAlias'] = $this->entityAliasResolver->getPluralAlias($class);
$item['entityId'] = $id;
$item['targetId'] = $targetId;
$item['targetClassName'] = $safeClassName;
$item['icon'] = $config->get('icon');
$item['link'] = $this->getContextLink($targetClass, $targetId);
$item = $this->dispatchContextTitle($item, $targetClass);
$result[] = $item;
}
return $result;
}
/**
* @param EmailTemplate $value
* @param Constraint|EmailTemplateSyntax $constraint
*/
public function validate($value, Constraint $constraint)
{
// prepare templates to be validated
$itemsToValidate = [['field' => 'subject', 'locale' => null, 'template' => $value->getSubject()], ['field' => 'content', 'locale' => null, 'template' => $value->getContent()]];
$translations = $value->getTranslations();
foreach ($translations as $trans) {
if (in_array($trans->getField(), ['subject', 'content'])) {
$itemsToValidate[] = ['field' => $trans->getField(), 'locale' => $trans->getLocale(), 'template' => $trans->getContent()];
}
}
/** @var \Twig_Extension_Sandbox $sandbox */
$sandbox = $this->twig->getExtension('sandbox');
$sandbox->enableSandbox();
// validate templates' syntax
$errors = [];
foreach ($itemsToValidate as &$item) {
try {
$this->twig->parse($this->twig->tokenize($item['template']));
} catch (\Twig_Error_Syntax $e) {
$errors[] = ['field' => $item['field'], 'locale' => $item['locale'], 'error' => $e->getMessage()];
}
}
$sandbox->disableSandbox();
// add violations for found errors
if (!empty($errors)) {
foreach ($errors as $error) {
$this->context->addViolation($constraint->message, ['{{ field }}' => $this->getFieldLabel(ClassUtils::getClass($value), $error['field']), '{{ locale }}' => $this->getLocaleName($error['locale']), '{{ error }}' => $error['error']]);
}
}
}
/**
* Handle onFlush event
*
* @param OnFlushEventArgs $event
*/
public function handleOnFlush(OnFlushEventArgs $event)
{
$em = $event->getEntityManager();
$uow = $em->getUnitOfWork();
$newEntities = $uow->getScheduledEntityInsertions();
foreach ($newEntities as $entity) {
if ($entity instanceof Call) {
$hasChanges = $this->activityManager->addActivityTarget($entity, $entity->getOwner());
// recompute change set if needed
if ($hasChanges) {
$uow->computeChangeSet($em->getClassMetadata(ClassUtils::getClass($entity)), $entity);
}
}
}
$changedEntities = $uow->getScheduledEntityUpdates();
foreach ($changedEntities as $entity) {
if ($entity instanceof Call) {
$hasChanges = false;
$changeSet = $uow->getEntityChangeSet($entity);
foreach ($changeSet as $field => $values) {
if ($field === 'owner') {
list($oldValue, $newValue) = $values;
if ($oldValue !== $newValue) {
$hasChanges |= $this->activityManager->replaceActivityTarget($entity, $oldValue, $newValue);
}
break;
}
}
// recompute change set if needed
if ($hasChanges) {
$uow->computeChangeSet($em->getClassMetadata(ClassUtils::getClass($entity)), $entity);
}
}
}
}
/**
* {@inheritdoc}
*/
public function update(PersistentCollection $collection)
{
if ($collection->isDirty() && $collection->getSnapshot()) {
throw CacheException::updateReadOnlyCollection(ClassUtils::getClass($collection->getOwner()), $this->association['fieldName']);
}
parent::update($collection);
}
/**
* {@inheritdoc}
*/
public function transform($value)
{
if (!$value) {
return '';
}
if (is_array($value)) {
$result = [];
$user = $this->securityFacade->getToken()->getUser();
foreach ($value as $target) {
if (ClassUtils::getClass($user) === ClassUtils::getClass($target) && $user->getId() === $target->getId()) {
continue;
}
if ($fields = $this->mapper->getEntityMapParameter(ClassUtils::getClass($target), 'title_fields')) {
$text = [];
foreach ($fields as $field) {
$text[] = $this->mapper->getFieldValue($target, $field);
}
} else {
$text = [(string) $target];
}
$text = implode(' ', $text);
if ($label = $this->getClassLabel(ClassUtils::getClass($target))) {
$text .= ' (' . $label . ')';
}
$result[] = json_encode(['text' => $text, 'id' => json_encode(['entityClass' => ClassUtils::getClass($target), 'entityId' => $target->getId()])]);
}
$value = implode(';', $result);
}
return $value;
}
/**
* @Route("/newPagePart", name="KunstmaanPagePartBundle_admin_newpagepart")
* @Template("KunstmaanPagePartBundle:PagePartAdminTwigExtension:pagepart.html.twig")
*
* @param \Symfony\Component\HttpFoundation\Request $request
*
* @return array
*/
public function newPagePartAction(Request $request)
{
$em = $this->getDoctrine()->getManager();
$pageId = $request->get('pageid');
$pageClassName = $request->get('pageclassname');
$context = $request->get('context');
$pagePartClass = $request->get('type');
$page = $em->getRepository($pageClassName)->findOneById($pageId);
$pagePartConfigurationReader = new PagePartConfigurationReader($this->container->get('kernel'));
$pagePartAdminConfigurators = $pagePartConfigurationReader->getPagePartAdminConfigurators($page);
$pagePartAdminConfigurator = null;
foreach ($pagePartAdminConfigurators as $ppac) {
if ($context == $ppac->getContext()) {
$pagePartAdminConfigurator = $ppac;
}
}
if (is_null($pagePartAdminConfigurator)) {
throw new \RuntimeException(sprintf('No page part admin configurator found for context "%s".', $context));
}
$pagePartAdmin = new PagePartAdmin($pagePartAdminConfigurator, $em, $page, $context, $this->container);
$pagePart = new $pagePartClass();
$formFactory = $this->container->get('form.factory');
$formBuilder = $formFactory->createBuilder(FormType::class);
$pagePartAdmin->adaptForm($formBuilder);
$id = 'newpp_' . time();
$data = $formBuilder->getData();
$data['pagepartadmin_' . $id] = $pagePart;
$adminType = $pagePart->getDefaultAdminType();
$adminTypeFqn = ClassUtils::getClass($adminType);
$formBuilder->add('pagepartadmin_' . $id, $adminTypeFqn);
$formBuilder->setData($data);
$form = $formBuilder->getForm();
$formview = $form->createView();
return array('id' => $id, 'form' => $formview, 'pagepart' => $pagePart, 'pagepartadmin' => $pagePartAdmin, 'editmode' => true);
}
/**
* @param FormEvent $event
*/
public function postSetData(FormEvent $event)
{
$form = $event->getForm();
if ($form->getParent()) {
return;
}
if (!$form->has($this->fieldName)) {
return;
}
$isEntityExists = false;
$entity = $event->getData();
if ($entity) {
if (!is_object($entity)) {
return;
}
$entityClass = ClassUtils::getClass($entity);
$entityManager = $this->managerRegistry->getManagerForClass($entityClass);
if (!$entityManager) {
return;
}
$entityIdentifier = $entityManager->getClassMetadata($entityClass)->getIdentifierValues($entity);
$isEntityExists = !empty($entityIdentifier);
}
// if entity exists and assign is not granted - replace field with disabled text field,
// otherwise - set default owner value
if ($isEntityExists) {
$this->replaceOwnerField($form);
} else {
$this->setPredefinedOwner($form);
}
}
/**
* Returns the context for the given email
*
* @param Email $email
*
* @return array
*/
public function getEmailContext(Email $email)
{
$criteria = Criteria::create();
$criteria->andWhere(Criteria::expr()->eq('id', $email->getId()));
$qb = $this->activityManager->getActivityTargetsQueryBuilder($this->class, $criteria);
if (null === $qb) {
return [];
}
$result = $qb->getQuery()->getResult();
if (empty($result)) {
return $result;
}
$currentUser = $this->securityFacade->getLoggedUser();
$currentUserClass = ClassUtils::getClass($currentUser);
$currentUserId = $currentUser->getId();
$result = array_values(array_filter($result, function ($item) use($currentUserClass, $currentUserId) {
return !($item['entity'] === $currentUserClass && $item['id'] == $currentUserId);
}));
foreach ($result as &$item) {
$route = $this->configManager->getEntityMetadata($item['entity'])->getRoute();
$item['entityId'] = $email->getId();
$item['targetId'] = $item['id'];
$item['targetClassName'] = $this->entityClassNameHelper->getUrlSafeClassName($item['entity']);
$item['icon'] = $this->configManager->getProvider('entity')->getConfig($item['entity'])->get('icon');
$item['link'] = $route ? $this->router->generate($route, ['id' => $item['id']]) : null;
unset($item['id'], $item['entity']);
}
return $result;
}
/**
* {@inheritdoc}
*/
public function save($group, array $options = [])
{
/* @var GroupInterface */
if (!$group instanceof GroupInterface) {
throw new \InvalidArgumentException(sprintf('Expects a "Pim\\Bundle\\CatalogBundle\\Model\\GroupInterface", "%s" provided.', ClassUtils::getClass($group)));
}
$this->eventDispatcher->dispatch(GroupEvents::PRE_SAVE, new GenericEvent($group));
$options = $this->optionsResolver->resolveSaveOptions($options);
$this->versionContext->addContextInfo(sprintf('Comes from variant group %s', $group->getCode()), $this->productClassName);
if ($group->getType()->isVariant()) {
$template = $group->getProductTemplate();
if (null !== $template) {
$this->templateMediaManager->handleProductTemplateMedia($template);
}
}
$this->objectManager->persist($group);
if (true === $options['flush']) {
$this->objectManager->flush();
}
if (count($options['add_products']) > 0) {
$this->addProducts($options['add_products']);
}
if (count($options['remove_products']) > 0) {
$this->removeProducts($options['remove_products']);
}
if ($group->getType()->isVariant() && true === $options['copy_values_to_products']) {
$this->copyVariantGroupValues($group);
}
$this->eventDispatcher->dispatch(GroupEvents::POST_SAVE, new GenericEvent($group));
}
/**
* Create a pending version for a versionable entity
*
* @param object $versionable
* @param string $author
* @param array $changeset
* @param string|null $context
*
* @return Version
*/
public function createPendingVersion($versionable, $author, array $changeset, $context = null)
{
$resourceName = ClassUtils::getClass($versionable);
$version = new Version($resourceName, $versionable->getId(), $author, $context);
$version->setChangeset($changeset);
return $version;
}
/**
* {@inheritdoc}
*/
public function setDefaults(MediaInterface $media, $parentPath = null)
{
$class = ClassUtils::getClass($media);
// check and add name if possible
if (!$media->getName()) {
if ($media->getId()) {
$media->setName(PathHelper::getNodeName($media->getId()));
} else {
throw new \RuntimeException(sprintf('Unable to set defaults, Media of type "%s" does not have a name or id.', $class));
}
}
$rootPath = is_null($parentPath) ? $this->rootPath : $parentPath;
$path = ($rootPath === '/' ? $rootPath : $rootPath . '/') . $media->getName();
/** @var DocumentManager $dm */
$dm = $this->getObjectManager();
// TODO use PHPCR autoname once this is done: http://www.doctrine-project.org/jira/browse/PHPCR-103
if ($dm->find($class, $path)) {
// path already exists
$media->setName($media->getName() . '_' . time() . '_' . rand());
}
if (!$media->getParent()) {
$parent = $dm->find(null, PathHelper::getParentPath($path));
$media->setParent($parent);
}
}
