/**
* Auto-Generate an alias for an entity.
*
* @param string $alias
* @param \DC_General $dc
*
* @return string
* @throws Exception
*/
public static function generateAlias($alias, \DC_General $dc)
{
/** @var EntityInterface $entity */
$entity = $dc->getCurrentModel()->getEntity();
$autoAlias = false;
// Generate alias if there is none
if (!strlen($alias)) {
$autoAlias = true;
if ($entity->__has('title')) {
$alias = standardize($entity->getTitle());
} elseif ($entity->__has('name')) {
$alias = standardize($entity->getName());
} else {
return '';
}
}
$entityClass = new \ReflectionClass($entity);
$keys = explode(',', $entityClass->getConstant('KEY'));
$entityManager = EntityHelper::getEntityManager();
$queryBuilder = $entityManager->createQueryBuilder();
$queryBuilder->select('COUNT(e.' . $keys[0] . ')')->from($entityClass->getName(), 'e')->where($queryBuilder->expr()->eq('e.alias', ':alias'))->setParameter(':alias', $alias);
static::extendQueryWhereId($queryBuilder, $dc->getCurrentModel()->getID(), $entity);
$query = $queryBuilder->getQuery();
$duplicateCount = $query->getResult(Query::HYDRATE_SINGLE_SCALAR);
// Check whether the news alias exists
if ($duplicateCount && !$autoAlias) {
throw new Exception(sprintf($GLOBALS['TL_LANG']['ERR']['aliasExists'], $alias));
}
// Add ID to alias
if ($duplicateCount && $autoAlias) {
$alias .= '-' . $dc->getCurrentModel()->getID();
}
return $alias;
}
/**
* @return EntityManager
*/
public function getEntityManager()
{
if (!$this->entityManager) {
$this->entityManager = EntityHelper::getEntityManager();
}
return $this->entityManager;
}
/**
* @param array $options
*
* @return array
*/
public function getNonBoilerplateMessages($options = array())
{
$entityManager = EntityHelper::getEntityManager();
$queryBuilder = $entityManager->createQueryBuilder();
/** @var Message[] $messages */
$messages = $queryBuilder->select('m')->from('Avisota\\Contao:Message', 'm')->innerJoin('Avisota\\Contao:MessageCategory', 'c', 'c.id=m.category')->where('c.boilerplates=:boilerplate')->orderBy('c.title', 'ASC')->addOrderBy('m.subject', 'ASC')->setParameter(':boilerplate', false)->getQuery()->getResult();
foreach ($messages as $message) {
$options[$message->getCategory()->getTitle()][$message->getId()] = $message->getSubject();
}
return $options;
}
/**
* @param null $limit
* @param null $offset
*
* @return array
* @SuppressWarnings(PHPMD.CamelCaseVariableName)
*/
public function getRecipients($limit = null, $offset = null)
{
global $container, $TL_LANG;
$queryBuilder = EntityHelper::getEntityManager()->createQueryBuilder();
$queryBuilder->select('r')->from('Avisota\\Contao:Recipient', 'r');
$this->prepareQuery($queryBuilder);
if ($limit > 0) {
$queryBuilder->setMaxResults($limit);
}
if ($offset > 0) {
$queryBuilder->setFirstResult($offset);
}
$queryBuilder->orderBy('r.email');
$query = $queryBuilder->getQuery();
$recipients = $query->getResult();
$entityAccessor = EntityHelper::getEntityAccessor();
$mutableRecipients = array();
/** @var EventDispatcherInterface $eventDispatcher */
$eventDispatcher = $container['event-dispatcher'];
/** @var Recipient $recipient */
foreach ($recipients as $recipient) {
$properties = $entityAccessor->getPublicProperties($recipient, true);
if ($this->manageSubscriptionUrlPattern) {
$loadLanguageEvent = new LoadLanguageFileEvent('fe_avisota_subscription');
$eventDispatcher->dispatch(ContaoEvents::SYSTEM_LOAD_LANGUAGE_FILE, $loadLanguageEvent);
$url = $this->manageSubscriptionUrlPattern;
$url = preg_replace_callback('~##([^#]+)##~', function ($matches) use($properties) {
if (isset($properties[$matches[1]])) {
return $properties[$matches[1]];
}
return $matches[0];
}, $url);
$properties['manage_subscription_link'] = array('url' => $url, 'text' => &$TL_LANG['fe_avisota_subscription']['manage_subscription']);
}
if ($this->unsubscribeUrlPattern) {
$loadLanguageEvent = new LoadLanguageFileEvent('fe_avisota_subscription');
$eventDispatcher->dispatch(ContaoEvents::SYSTEM_LOAD_LANGUAGE_FILE, $loadLanguageEvent);
$url = $this->unsubscribeUrlPattern;
$url = preg_replace_callback('~##([^#]+)##~', function ($matches) use($properties) {
if (isset($properties[$matches[1]])) {
return $properties[$matches[1]];
}
return $matches[0];
}, $url);
$properties['unsubscribe_link'] = array('url' => $url, 'text' => &$TL_LANG['fe_avisota_subscription']['unsubscribe_direct']);
}
$mutableRecipients[] = new MutableRecipient($recipient->getEmail(), $properties);
}
return $mutableRecipients;
}
/**
* @param ResolveRecipientEvent $event
*/
public function resolveRecipient(ResolveRecipientEvent $event)
{
// some other event listener has already resolved the recipient
if ($event->getRecipient()) {
return;
}
$subscription = $event->getSubscription();
if ($subscription->getRecipientType() == 'Avisota\\Contao\\Entity\\Recipient') {
$entityManager = EntityHelper::getEntityManager();
$repository = $entityManager->getRepository('Avisota\\Contao\\Entity\\Recipient');
$recipient = $repository->find($subscription->getRecipientId());
$event->setRecipient($recipient);
}
}
public static function addRecipient($strEmail, $arrMailingListIds, $strConfirmationMessageId, $intJumpTo)
{
$repository = EntityHelper::getRepository('Avisota\\Contao:Recipient');
if (($recipient = $repository->findOneBy(array('email' => $strEmail))) === null) {
$recipient = new Recipient();
$entityAccessor = $GLOBALS['container']['doctrine.orm.entityAccessor'];
try {
$entityAccessor->setProperty($recipient, 'email', $strEmail);
} catch (UnknownPropertyException $e) {
// gracefully ignore non-public properties
}
}
$entityManager = EntityHelper::getEntityManager();
$entityManager->persist($recipient);
$mailingLists = static::loadMailingLists(deserialize($arrMailingListIds, true));
$subscriptionManager = $GLOBALS['container']['avisota.subscription'];
$subscriptions = $subscriptionManager->subscribe($recipient, $mailingLists, SubscriptionManager::OPT_IGNORE_BLACKLIST | SubscriptionManager::OPT_INCLUDE_EXISTING);
$subscriptions = array_filter($subscriptions, function (Subscription $subscription) {
return !$subscription->getActive();
});
/** @var Subscription[] $subscriptions */
$_SESSION['AVISOTA_LAST_SUBSCRIPTIONS'] = $subscriptions;
$entityManager->flush();
if (count($subscriptions)) {
$eventDispatcher = $GLOBALS['container']['event-dispatcher'];
if ($intJumpTo) {
$event = new GetPageDetailsEvent($intJumpTo);
$eventDispatcher->dispatch(ContaoEvents::CONTROLLER_GET_PAGE_DETAILS, $event);
$pageDetails = $event->getPageDetails();
} else {
$pageDetails = $GLOBALS['objPage']->row();
}
$event = new GenerateFrontendUrlEvent($pageDetails);
$eventDispatcher->dispatch(ContaoEvents::CONTROLLER_GENERATE_FRONTEND_URL, $event);
$query = array('token' => array());
foreach ($subscriptions as $subscription) {
$query['token'][] = $subscription->getActivationToken();
}
$base = \Environment::get('base');
$url = $base . $event->getUrl() . '?' . http_build_query($query);
\System::loadLanguageFile('fe_avisota_subscription');
$data = array('link' => array('url' => $url, 'text' => $GLOBALS['TL_LANG']['fe_avisota_subscription']['confirm']), 'subscriptions' => $subscriptions);
static::sendAvisotaEMail($strConfirmationMessageId, $recipient, $data);
}
}
public function captureSendImmediate(PostSendImmediateEvent $event)
{
$entityManager = EntityHelper::getEntityManager();
$historyRepository = $entityManager->getRepository('Avisota\\Contao\\Entity\\MessageHistory');
// get the history
$loop = $event->getLoop();
if ($loop) {
$history = $historyRepository->findOneBy(array('loop' => $loop));
}
//create a new history if none was found
if (!$history) {
$history = new MessageHistory();
$history->setMessage($event->getMessage());
$history->setLoop($event->getLoop());
}
$history->setMailCount($history->getMailCount() + $event->getCount());
$entityManager->persist($history);
}
/**
* @SuppressWarnings(PHPMD.LongVariable)
*/
public function regenerateDynamics()
{
$dynamics = array();
// $mailingListRepository = EntityHelper::getRepository('Avisota\Contao:MailingList');
$recipientSourceRepository = EntityHelper::getRepository('Avisota\\Contao:RecipientSource');
// $themeRepository = EntityHelper::getRepository('Avisota\Contao:Theme');
$transportRepository = EntityHelper::getRepository('Avisota\\Contao:Transport');
$queueRepository = EntityHelper::getRepository('Avisota\\Contao:Queue');
/** @var EntityRepository[] $repositories */
$repositories = array($queueRepository, $recipientSourceRepository, $transportRepository);
foreach ($repositories as $repository) {
$entityName = $repository->getClassName();
$entityName = str_replace('Avisota\\Contao\\Entity\\', '', $entityName);
$entityName = lcfirst($entityName);
$entities = $repository->findAll();
$dynamics[$entityName] = array();
foreach ($entities as $entity) {
/** @noinspection PhpUndefinedMethodInspection */
$dynamics[$entityName][] = array('id' => $entity->id(), 'alias' => $entity->getAlias(), 'title' => $entity->getTitle());
}
}
$queryBuilder = EntityHelper::getEntityManager()->createQueryBuilder();
$query = $queryBuilder->select('c')->from('Avisota\\Contao:MessageCategory', 'c')->where('c.showInMenu=:showInMenu')->andWhere('c.boilerplates=:boilerplates')->setParameter(':showInMenu', true)->setParameter(':boilerplates', false)->orderBy('c.title')->getQuery();
$categories = $query->getResult();
$dynamics['category'] = array();
/** @var MessageCategory $category */
foreach ($categories as $category) {
/** @noinspection PhpUndefinedMethodInspection */
$dynamics['category'][] = array('id' => $category->id(), 'label' => $category->getTitle(), 'icon' => $category->getUseCustomMenuIcon() ? $category->getMenuIcon() : false);
}
$array = var_export($dynamics, true);
$fileContents = <<<EOF
<?php
return {$array};
EOF;
$tempFile = new \File('system/modules/avisota/config/dynamics.php');
$tempFile->write($fileContents);
$tempFile->close();
}
/**
* Return the "toggle visibility" button
*
* @param array
* @param string
* @param string
* @param string
* @param string
* @param string
*
* @return string
* @SuppressWarnings(PHPMD.ShortVariable)
* @SuppressWarnings(PHPMD.LongVariable)
*/
public function toggleIcon($row, $href, $label, $title, $icon, $attributes)
{
$subscriptionRepository = EntityHelper::getRepository('Avisota\\Contao:Subscription');
/** @var \Avisota\Contao\Entity\Subscription $subscription */
if (strlen(\Input::get('tid'))) {
$id = \Input::get('tid');
$confirmed = \Input::get('state') == 1;
/** @var \Avisota\Contao\Entity\Subscription $subscription */
$subscription = $subscriptionRepository->find($id);
$subscription->setConfirmed($confirmed);
$entityManager = EntityHelper::getEntityManager();
$entityManager->persist($subscription);
$entityManager->flush($subscription);
$this->redirect($this->getReferer());
}
$subscription = $subscriptionRepository->findOneBy(array('recipient' => $row['recipient'], 'list' => $row['list']));
$href .= '&tid=' . $subscription->id() . '&state=' . ($row['confirmed'] ? '' : 1);
if (!$row['confirmed']) {
$icon = 'invisible.gif';
}
return '<a href="' . $this->addToUrl($href) . '" title="' . specialchars($title) . '"' . $attributes . '>' . $this->generateImage($icon, $label) . '</a> ';
}
/**
* @SuppressWarnings(PHPMD.Superglobals)
*/
public function cronCleanupRecipientList()
{
if (!$GLOBALS['TL_CONFIG']['avisota_subscription_cleanup']) {
return;
}
/** @var EventDispatcher $eventDispatcher */
$eventDispatcher = $GLOBALS['container']['event-dispatcher'];
$cleanupDate = new \DateTime();
$cleanupDate->sub(new \DateInterval('P' . $GLOBALS['TL_CONFIG']['avisota_subscription_cleanup_days'] . 'D'));
$entityManager = EntityHelper::getEntityManager();
$repository = $entityManager->getRepository('Avisota\\Contao:Subscription');
$queryBuilder = $repository->createQueryBuilder('s');
$expr = $queryBuilder->expr();
$queryBuilder->select('s')->where($expr->eq('s.confirmed', ':confirmed'))->andWhere($expr->lt('s.updatedAt', ':cleanupDate'))->setParameter('confirmed', true)->setParameter('cleanupDate', $cleanupDate);
$query = $queryBuilder->getQuery();
$subscriptions = $query->getResult();
foreach ($subscriptions as $subscription) {
$entityManager->remove($subscription);
$event = new CleanSubscriptionEvent($subscription);
$eventDispatcher->dispatch(SubscriptionEvents::CLEAN_SUBSCRIPTION, $event);
}
$entityManager->flush();
}
public function generateSchemaSql($return)
{
$entityManager = EntityHelper::getEntityManager();
$cacheDriver = $entityManager->getConfiguration()->getMetadataCacheImpl();
if ($cacheDriver && !$cacheDriver instanceof ApcCache) {
$cacheDriver->deleteAll();
}
// force "disconnected" generation of entities
$reload = false;
EntityGeneration::generate(null, $reload);
if ($reload) {
$this->reload();
}
$metadatas = $entityManager->getMetadataFactory()->getAllMetadata();
$tool = new SchemaTool($entityManager);
$queries = $tool->getUpdateSchemaSql($metadatas);
$filter = array_map('preg_quote', $GLOBALS['DOCTRINE_MANAGED_TABLE']);
$filter = implode('|', $filter);
$filter = sprintf('~^(CREATE|ALTER|DROP) TABLE (%s)~', $filter);
$queries = array_filter($queries, function ($query) use($filter) {
return preg_match($filter, $query);
});
return $this->appendQueries($return, $queries);
}
/**
* @param $form
* @param $recipientFields
* @param $mailingListIds
*/
protected function parseSubscriptions($form, $recipientFields, $mailingListIds)
{
if (!$form->validate()) {
return;
}
global $container;
/** @var SubscriptionManager $subscriptionManager */
$subscriptionManager = $container['avisota.subscription'];
/** @var EventDispatcher $eventDispatcher */
$eventDispatcher = $container['event-dispatcher'];
$values = $form->fetchAll();
$email = $values['email'];
$repository = EntityHelper::getRepository('Avisota\\Contao:Recipient');
$recipient = $repository->findOneBy(array('email' => $email));
if (!$recipient) {
$recipient = new Recipient();
}
$this->setPropertiesToRecipient($recipient, $values);
$entityManager = EntityHelper::getEntityManager();
$entityManager->persist($recipient);
if (in_array('mailingLists', $recipientFields)) {
$mailingLists = $this->loadMailingLists($values['mailingLists']);
} else {
$mailingLists = $this->loadMailingLists($mailingListIds);
}
$subscriptions = $subscriptionManager->subscribe($recipient, $mailingLists, SubscriptionManager::OPT_IGNORE_BLACKLIST | SubscriptionManager::OPT_INCLUDE_EXISTING);
$subscriptions = array_filter($subscriptions, function (Subscription $subscription) {
return !$subscription->getActive();
});
/** @var Subscription[] $subscriptions */
\Session::getInstance()->set('AVISOTA_LAST_SUBSCRIPTIONS', $subscriptions);
$entityManager->flush();
if (count($subscriptions)) {
$this->subscribeConfirmationMessage($subscriptions, $recipient);
if ($this->avisota_subscribe_confirmation_page) {
$event = new GetPageDetailsEvent($this->avisota_subscribe_confirmation_page);
$eventDispatcher->dispatch(ContaoEvents::CONTROLLER_GET_PAGE_DETAILS, $event);
$event = new GenerateFrontendUrlEvent($event->getPageDetails());
$eventDispatcher->dispatch(ContaoEvents::CONTROLLER_GENERATE_FRONTEND_URL, $event);
$event = new RedirectEvent($event->getUrl());
$eventDispatcher->dispatch(ContaoEvents::CONTROLLER_REDIRECT, $event);
}
}
$this->Template->subscriptions = $subscriptions;
}
/**
* @param EnvironmentInterface $environment
* @param $migrationSettings
* @param $migrationId
*
* @return null|string
* @SuppressWarnings(PHPMD.CamelCaseVariableName)
* @SuppressWarnings(PHPMD.LongVariable)
* @SuppressWarnings(PHPMD.CyclomaticComplexity)
* @SuppressWarnings(PHPMD.NPathComplexity)
* @SuppressWarnings(PHPMD.ExcessiveMethodLength)
*/
protected function generateResponse(EnvironmentInterface $environment, $migrationSettings, $migrationId)
{
global $container;
$eventDispatcher = $container['event-dispatcher'];
$input = $environment->getInputProvider();
$translator = $environment->getTranslator();
$entityManager = EntityHelper::getEntityManager();
$recipientRepository = EntityHelper::getRepository('Avisota\\Contao:Recipient');
list($offset, $skipped, $migrated, $channelMailingListMapping, $statement) = $this->getMigrationStatement($migrationSettings);
/** @var SubscriptionManager $subscriptionManager */
$subscriptionManager = $container['avisota.subscription'];
$subscribeOptions = 0;
if ($migrationSettings['ignoreBlacklist']) {
$subscribeOptions |= SubscriptionManager::OPT_IGNORE_BLACKLIST;
}
$user = \BackendUser::getInstance();
$response = new StringBuilder();
$this->addHeaderContent($response, $translator);
$contaoRecipients = $statement->fetchAll();
$lastNewMigrationRecipient = (array) \Session::getInstance()->get('AVISOTA_LAST_MIGRATION_RECIPIENT' . $input->getParameter('migration'));
foreach ($contaoRecipients as $contaoRecipientData) {
$recipient = $recipientRepository->findOneBy(array('email' => $contaoRecipientData['email']));
if ($recipient && in_array($recipient->getEmail(), $lastNewMigrationRecipient)) {
$migrationSettings['overwrite'] = true;
}
if (!$recipient) {
$this->addCreateRecipientInformation($response, $contaoRecipientData, $translator);
$recipient = new Recipient();
$recipient->setEmail($contaoRecipientData['email']);
$recipient->setAddedById($user->id);
$recipient->setAddedByName($user->name);
$recipient->setAddedByUsername($user->username);
} else {
if (!$migrationSettings['overwrite']) {
$skipped++;
continue;
} else {
$this->addSkippedRecipientInformation($response, $contaoRecipientData, $translator);
}
}
$mailingList = $channelMailingListMapping[$contaoRecipientData['pid']];
if (!$mailingList) {
// graceful ignore missing mailing lists
$skipped++;
continue;
}
$migrateRecipientEvent = new MigrateRecipientEvent($migrationSettings, $contaoRecipientData, $recipient);
$eventDispatcher->dispatch(RecipientEvents::MIGRATE_RECIPIENT, $migrateRecipientEvent);
if (!$recipient->getId()) {
$lastNewMigrationRecipient[] = $recipient->getEmail();
}
$entityManager->persist($recipient);
$subscriptionManager->subscribe($recipient, $mailingList, ($contaoRecipientData['active'] ? SubscriptionManager::OPT_ACTIVATE : 0) | $subscribeOptions);
$migrated++;
}
$entityManager->flush();
if (count($contaoRecipients) < 10) {
\Session::getInstance()->set('AVISOTA_LAST_MIGRATION_RECIPIENT' . $input->getParameter('migration'), array());
$this->migrationFinished($migrationId, $migrated, $skipped);
return null;
} else {
$offset += count($contaoRecipients);
$this->updateRedirectSession($migrationId, $offset, $skipped, $migrated, $migrationSettings['channels'], $migrationSettings['overwrite'], $migrationSettings['importFromMembers']);
$this->addReloadScriptAndButton($response, $translator);
\Session::getInstance()->set('AVISOTA_LAST_MIGRATION_RECIPIENT' . $input->getParameter('migration'), $lastNewMigrationRecipient);
return $response->__toString();
}
}
protected function execute(Message $message, \BackendUser $user)
{
global $container;
$input = \Input::getInstance();
$environment = Environment::getInstance();
$eventDispatcher = $this->getEventDispatcher();
$entityManager = EntityHelper::getEntityManager();
$queueData = $message->getQueue();
$serviceName = sprintf('avisota.queue.%s', $queueData->getId());
$queue = $container[$serviceName];
$recipientSourceData = $message->getRecipients();
$serviceName = sprintf('avisota.recipientSource.%s', $recipientSourceData->getId());
/** @var \Avisota\RecipientSource\RecipientSourceInterface $recipientSource */
$recipientSource = $container[$serviceName];
/** @var \Avisota\Contao\Message\Core\Renderer\MessageRendererInterface $renderer */
$renderer = $container['avisota.message.renderer'];
$messageTemplate = $renderer->renderMessage($message);
$event = new LoadLanguageFileEvent('avisota_message');
$eventDispatcher->dispatch(ContaoEvents::SYSTEM_LOAD_LANGUAGE_FILE, $event);
$idSerializer = new IdSerializer();
$idSerializer->setDataProviderName('orm_avisota_message');
$idSerializer->setId($message->getId());
$pidSerializer = new IdSerializer();
$pidSerializer->setDataProviderName('orm_avisota_message_category');
$pidSerializer->setId($message->getCategory()->getId());
$viewOnlinePage = $message->getCategory()->getViewOnlinePage();
if ($viewOnlinePage) {
$getPageDetailsEvent = new GetPageDetailsEvent($viewOnlinePage);
$eventDispatcher->dispatch(ContaoEvents::CONTROLLER_GET_PAGE_DETAILS, $getPageDetailsEvent);
$pageDetails = $getPageDetailsEvent->getPageDetails();
$generateUrlEvent = new GenerateFrontendUrlEvent($pageDetails, '/' . $message->getAlias(), $pageDetails['language']);
$eventDispatcher->dispatch(ContaoEvents::CONTROLLER_GENERATE_FRONTEND_URL, $generateUrlEvent);
$url = $generateUrlEvent->getUrl();
if (!preg_match('~^\\w+:~', $url)) {
$url = $environment->base . $url;
}
$generateViewOnlineUrlEvent = new GenerateViewOnlineUrlEvent($message, $url);
$eventDispatcher->dispatch(MessageEvents::GENERATE_VIEW_ONLINE_URL, $generateViewOnlineUrlEvent);
$url = sprintf($GLOBALS['TL_LANG']['avisota_message']['viewOnline'], $generateViewOnlineUrlEvent->getUrl());
} else {
$url = false;
}
// TODO fix view online link
$additionalData = array('view_online_link' => $url);
$turn = $input->get('turn');
if (!$turn) {
$turn = 0;
}
$loop = $input->get('loop');
if (!$loop) {
$loop = uniqid();
}
$event = new \Avisota\Contao\Core\Event\PreSendImmediateEvent($message, $turn, $loop);
$eventDispatcher->dispatch('avisota.pre-send-immediate', $event);
$queueHelper = new \Avisota\Queue\QueueHelper();
$queueHelper->setEventDispatcher($GLOBALS['container']['event-dispatcher']);
$queueHelper->setQueue($queue);
$queueHelper->setRecipientSource($recipientSource);
$queueHelper->setMessageTemplate($messageTemplate);
$queueHelper->setNewsletterData($additionalData);
$count = $queueHelper->enqueue(30, $turn * 30);
$event = new \Avisota\Contao\Core\Event\PostSendImmediateEvent($count, $message, $turn, $loop);
$eventDispatcher->dispatch('avisota.post-send-immediate', $event);
if ($count || $turn * 30 + 30 < $recipientSource->countRecipients()) {
$eventDispatcher->dispatch(ContaoEvents::SYSTEM_LOAD_LANGUAGE_FILE, new LoadLanguageFileEvent('avisota_message_preview'));
$_SESSION['TL_CONFIRM'][] = sprintf($GLOBALS['TL_LANG']['avisota_message_preview']['messagesEnqueued'], $count, $turn + 1);
$parameters = array('id' => $message->getId(), 'turn' => $turn + 1, 'loop' => $loop);
$url = sprintf('%ssystem/modules/avisota-message/web/send_immediate.php?%s', $environment->base, http_build_query($parameters));
$entityManager->flush();
} else {
$parameters = array('do' => 'avisota_outbox', 'execute' => $queueData->getId());
$url = sprintf('%scontao/main.php?%s', $environment->base, http_build_query($parameters));
$message->setSendOn(new \DateTime());
$entityManager->persist($message);
$entityManager->flush();
}
echo '<html><head><meta http-equiv="refresh" content="0; URL=' . $url . '"></head><body>Still generating...</body></html>';
exit;
}
/**
* @param $contents
*/
protected function resetContent($contents)
{
if (count($contents) < 1) {
return;
}
$entityManager = EntityHelper::getEntityManager();
foreach ($contents as $content) {
if ($content instanceof EntityInterface) {
$entityManager->refresh($content);
}
if ($content instanceof \Model) {
$content->refresh();
}
}
}
/**
* Auto-Generate an alias for an entity.
*
* @param string $alias
* @param EntityInterface $entity
*
* @return string
* @throws \Exception
*/
public static function generateAlias($alias, $entity, $baseField = false)
{
$customAlias = (bool) $alias;
$turn = 0;
do {
// Generate alias if there is none
if (!strlen($alias)) {
/** @var EntityAccessor $entityAccessor */
$entityAccessor = $GLOBALS['container']['doctrine.orm.entityAccessor'];
if ($baseField) {
$alias = standardize($entityAccessor->getProperty($entity, $baseField));
} elseif ($entity instanceof AliasableInterface) {
$alias = standardize($entity->getAliasParentValue());
} elseif ($entityAccessor->hasProperty($entity, 'title')) {
$alias = standardize($entityAccessor->getProperty($entity, 'title'));
} elseif ($entityAccessor->hasProperty($entity, 'name')) {
$alias = standardize($entityAccessor->getProperty($entity, 'name'));
} else {
throw new \RuntimeException('Cannot generate alias, do not know which field should used!');
}
}
if ($turn > 0) {
$alias .= '-' . $turn;
}
$entityClass = new \ReflectionClass($entity);
if ($entityClass->hasConstant('PRIMARY_KEY')) {
$keys = explode(',', $entityClass->getConstant('PRIMARY_KEY'));
} else {
$keys = array('id');
}
$entityManager = EntityHelper::getEntityManager();
$queryBuilder = $entityManager->createQueryBuilder();
$queryBuilder->select('COUNT(e.' . $keys[0] . ')')->from($entityClass->getName(), 'e')->where($queryBuilder->expr()->eq('e.alias', ':alias'))->setParameter(':alias', $alias);
static::extendQueryWhereId($queryBuilder, $entity);
$query = $queryBuilder->getQuery();
$duplicateCount = $query->getResult(Query::HYDRATE_SINGLE_SCALAR);
// Check whether the news alias exists
if ($duplicateCount && $customAlias) {
throw new \Exception(sprintf($GLOBALS['TL_LANG']['ERR']['aliasExists'], $alias));
}
$turn++;
} while ($duplicateCount);
return $alias;
}
