_id
stringlengths 2
7
| title
stringlengths 3
151
| partition
stringclasses 3
values | text
stringlengths 83
13k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q244900 | CustomSql.getSubscribedServices | validation | public static function getSubscribedServices()
{
return [
Connection::class => Connection::class,
Input::class => Input::class,
InsertTags::class => InsertTags::class,
Session::class => Session::class,
// This one is deprecated.
IMetaModelsServiceContainer::class => IMetaModelsServiceContainer::class
];
} | php | {
"resource": ""
} |
q244901 | CustomSql.getFilterRule | validation | private function getFilterRule()
{
$this->compile();
return new SimpleQuery(
$this->queryString,
$this->queryParameter,
'id',
$this->container->get(Connection::class)
);
} | php | {
"resource": ""
} |
q244902 | CustomSql.addParameters | validation | private function addParameters($parameters)
{
if (empty($parameters)) {
return;
}
$this->queryParameter = array_merge($this->queryParameter, $parameters);
} | php | {
"resource": ""
} |
q244903 | CustomSql.parseTable | validation | private function parseTable()
{
$this->queryString = str_replace(
'{{table}}',
$this->collection->getMetaModel()->getTableName(),
$this->queryString
);
} | php | {
"resource": ""
} |
q244904 | CustomSql.getValueFromServiceContainer | validation | private function getValueFromServiceContainer($valueName, $arguments)
{
if (!empty($arguments['service'])) {
$serviceName = $arguments['service'];
} else {
$serviceName = $valueName;
}
$service = $this->container->get(IMetaModelsServiceContainer::class)->getService($serviceName);
if (is_callable($service)) {
return call_user_func($service, $valueName, $arguments);
}
return 'NULL';
} | php | {
"resource": ""
} |
q244905 | CustomSql.getValueFromSource | validation | private function getValueFromSource($source, $valueName, $arguments)
{
switch (strtolower($source)) {
case 'get':
return $this->container->get(Input::class)->get($valueName);
case 'post':
return $this->container->get(Input::class)->post($valueName);
case 'cookie':
return $this->container->get(Input::class)->cookie($valueName);
case 'session':
return $this->container->get(Session::class)->get($valueName);
case 'filter':
if (is_array($this->filterParameters)) {
if (array_key_exists($valueName, $this->filterParameters)) {
return $this->filterParameters[$valueName];
}
return null;
}
break;
case 'container':
// @codingStandardsIgnoreStart
@trigger_error(
'Getting filter values from the service container is deprecated, the container will get removed.',
E_USER_DEPRECATED
);
// @codingStandardsIgnoreEnd
return $this->getValueFromServiceContainer($valueName, $arguments);
default:
}
// Unknown sources always resort to null.
return null;
} | php | {
"resource": ""
} |
q244906 | CustomSql.convertParameterAggregate | validation | private function convertParameterAggregate($var, $arguments)
{
// Treat as list.
$var = (array) $var;
if (!empty($arguments['recursive'])) {
$var = iterator_to_array(
new \RecursiveIteratorIterator(
new \RecursiveArrayIterator(
$var
)
)
);
}
if (!$var) {
return 'NULL';
}
if (!empty($arguments['key'])) {
$var = array_keys($var);
} else {
// Use values.
$var = array_values($var);
}
if ($arguments['aggregate'] == 'set') {
$this->addParameter(implode(',', $var));
return '?';
}
$this->addParameters($var);
return rtrim(str_repeat('?,', count($var)), ',');
} | php | {
"resource": ""
} |
q244907 | CustomSql.convertParameter | validation | public function convertParameter($arrMatch)
{
list($strSource, $strQuery) = explode('?', $arrMatch[1], 2);
parse_str($strQuery, $arrArgs);
$arrName = (array) $arrArgs['name'];
$var = $this->getValueFromSource($strSource, array_shift($arrName), $arrArgs);
$index = 0;
$count = count($arrName);
while ($index < $count && is_array($var)) {
$var = $var[$arrName[$index++]];
}
if ($index != $count || $var === null) {
if (array_key_exists('default', $arrArgs) && (null !== $arrArgs['default'])) {
$this->addParameter($arrArgs['default']);
return '?';
} else {
return 'NULL';
}
}
// Treat as scalar value.
if (!isset($arrArgs['aggregate'])) {
$this->addParameter($var);
return '?';
}
return $this->convertParameterAggregate($var, $arrArgs);
} | php | {
"resource": ""
} |
q244908 | ConnectionTrait.getRow | validation | private function getRow($rowId, $table)
{
return (object) $this->connection
->createQueryBuilder()
->select('*')
->from($table)
->where('id=:id')
->setParameter('id', $rowId)
->setMaxResults(1)
->execute()
->fetch(\PDO::FETCH_ASSOC);
} | php | {
"resource": ""
} |
q244909 | FilterUrlBuilder.generate | validation | public function generate(FilterUrl $filterUrl)
{
$jumpTo = $filterUrl->getPage();
// If no alias given, stay on current page.
if (empty($jumpTo['alias'])) {
$this->addFromCurrentRequest($filterUrl = $filterUrl->clone(), []);
$jumpTo = $filterUrl->getPage();
}
$alias = $jumpTo['alias'];
$parameters = $filterUrl->getGetParameters();
$url = $alias;
if ($filterUrl->hasSlug('auto_item')) {
$url .= '/' . $this->encodeForAllowEncodedSlashes($filterUrl->getSlug('auto_item'));
}
if (!empty($jumpTo['domain'])) {
$parameters['_domain'] = $jumpTo['domain'];
}
if (!empty($jumpTo['rootUseSSL'])) {
$parameters['_ssl'] = (bool) $jumpTo['rootUseSSL'];
}
if ($filterUrl->hasSlug('language')) {
$parameters['_locale'] = $filterUrl->getSlug('language');
}
foreach ($filterUrl->getSlugParameters() as $name => $value) {
if (in_array($name, ['language', 'auto_item'])) {
continue;
}
// Encode slashes in slugs - otherwise Symfony won't handle them correctly.
// This mitigates for http://httpd.apache.org/docs/current/mod/core.html#allowencodedslashes
// If not given, apache would 404 otherwise.
$url .= '/' . $this->encodeForAllowEncodedSlashes($name) .
'/' . $this->encodeForAllowEncodedSlashes($value);
}
return $this->urlGenerator->generate($url, $parameters);
} | php | {
"resource": ""
} |
q244910 | FilterUrlBuilder.getCurrentFilterUrl | validation | public function getCurrentFilterUrl($options = null): FilterUrl
{
$this->addFromCurrentRequest($filterUrl = new FilterUrl(), $options);
return $filterUrl;
} | php | {
"resource": ""
} |
q244911 | FilterUrlBuilder.determineFragments | validation | private function determineFragments(Request $request): ?array
{
if (null === $requestUri = $this->strippedUri($request)) {
return null;
}
$fragments = null;
// Use folder-style URLs
if (Config::get('folderUrl') && false !== strpos($requestUri, '/')) {
$fragments = $this->getFolderUrlFragments(
$requestUri,
$request->getHost(),
$request->attributes->get('_locale')
);
}
// If folderUrl is deactivated or did not find a matching page
if (null === $fragments) {
if ('/' === $requestUri) {
return null;
}
$fragments = explode('/', $requestUri);
}
// Add the second fragment as auto_item if the number of fragments is even
if (Config::get('useAutoItem') && 0 === (\count($fragments) % 2)) {
array_insert($fragments, 1, ['auto_item']);
}
$fragments = $this->getPageIdFromUrlHook($fragments);
// Return if the alias is empty (see #4702 and #4972)
if (null === $fragments || ('' === $fragments[0] && \count($fragments) > 1)) {
return null;
}
return $fragments;
} | php | {
"resource": ""
} |
q244912 | FilterUrlBuilder.getFolderUrlFragments | validation | private function getFolderUrlFragments(string $alias, string $host, string $locale = null): ?array
{
// Check if there are pages with a matching alias
$pages = $this->getPageCandidates($alias);
if (null === $pages) {
return null;
}
// Look for a root page whose domain name matches the host name
if (isset($pages[$host])) {
$languages = $pages[$host];
} else {
// empty domain
$languages = $pages['*'] ?: [];
}
unset($pages);
$pages = [];
if (!$this->isLocalePrepended) {
// Use the first result (see #4872)
$pages = current($languages);
} elseif ($locale && isset($languages[$locale])) {
// Try to find a page matching the language parameter
$pages = $languages[$locale];
}
// Return if there are no matches
if (empty($pages)) {
return null;
}
/** @var PageModel $page */
$page = $pages[0];
// The request consists of the alias only
if ($alias == $page->alias) {
$arrFragments = [$alias];
} else {
// Remove the alias from the request string, explode it and then re-insert it at the beginning.
$arrFragments = explode('/', substr($alias, (\strlen($page->alias) + 1)));
array_unshift($arrFragments, $page->alias);
}
return $arrFragments;
} | php | {
"resource": ""
} |
q244913 | FilterUrlBuilder.getPageCandidates | validation | private function getPageCandidates(string $alias)
{
$aliases = [$alias];
// Compile all possible aliases by applying dirname() to the request.
while ('/' !== $alias && false !== strpos($alias, '/')) {
$alias = \dirname($alias);
$aliases[] = $alias;
}
// Check if there are pages with a matching alias
$pages = $this->pageModelAdapter->findByAliases($aliases);
if (null === $pages) {
return null;
}
$arrPages = [];
// Order by domain and language
while ($pages->next()) {
/** @var PageModel $objModel */
$objModel = $pages->current();
$objPage = $objModel->loadDetails();
$domain = $objPage->domain ?: '*';
$arrPages[$domain][$objPage->rootLanguage][] = $objPage;
// Also store the fallback language
if ($objPage->rootIsFallback) {
$arrPages[$domain]['*'][] = $objPage;
}
}
return $arrPages;
} | php | {
"resource": ""
} |
q244914 | FilterUrlBuilder.getPageIdFromUrlHook | validation | private function getPageIdFromUrlHook(?array $fragments): ?array
{
if (!(isset($GLOBALS['TL_HOOKS']['getPageIdFromUrl']) && \is_array($GLOBALS['TL_HOOKS']['getPageIdFromUrl']))) {
return $fragments;
}
foreach ($GLOBALS['TL_HOOKS']['getPageIdFromUrl'] as $callback) {
$fragments = System::importStatic($callback[0])->{$callback[1]}($fragments);
}
return $fragments;
} | php | {
"resource": ""
} |
q244915 | FilterUrlBuilder.extractPostData | validation | private function extractPostData(FilterUrl $filterUrl, $options, Request $request): void
{
if (empty($options['postAsSlug']) && empty($options['postAsGet'])) {
return;
}
foreach ($request->request->all() as $name => $value) {
if (is_array($value)) {
$value = implode(',', $value);
}
if (in_array($name, $options['postAsSlug'])) {
$filterUrl->setSlug($name, $value);
}
if (in_array($name, $options['postAsGet'])) {
$filterUrl->setGet($name, $value);
}
}
} | php | {
"resource": ""
} |
q244916 | CollectFactoriesPass.collectAttributeFactories | validation | private function collectAttributeFactories($container)
{
$attributeFactory = $container->getDefinition('metamodels.attribute_factory');
foreach (array_keys($container->findTaggedServiceIds(self::TAG_ATTRIBUTE_FACTORY)) as $factory) {
$attributeFactory->addMethodCall('addTypeFactory', [new Reference($factory)]);
}
} | php | {
"resource": ""
} |
q244917 | TableManipulator.checkColumnDoesNotExist | validation | public function checkColumnDoesNotExist($strTableName, $strColName, $blnAllowSystemCol = false)
{
$this->checkTableExists($strTableName);
$this->checkColumnName($strColName, $blnAllowSystemCol);
if ($this->fieldExists($strColName, $strTableName)) {
throw ColumnExistsException::withName($strColName, $strTableName);
}
} | php | {
"resource": ""
} |
q244918 | TableManipulator.fieldExists | validation | private function fieldExists($strTableName, $strColumnName)
{
$columns = $this->connection->getSchemaManager()->listTableColumns($strTableName);
return isset($columns[$strColumnName]);
} | php | {
"resource": ""
} |
q244919 | FileSelectorWidget.generateAjax | validation | public function generateAjax($folder, $strField, $level, $mount = false)
{
return parent::generateAjax($folder, $this->strField, $level, $mount);
} | php | {
"resource": ""
} |
q244920 | UserListener.buildBackendModules | validation | private function buildBackendModules(&$localMenu)
{
foreach ($this->viewCombination->getStandalone() as $metaModelName => $screen) {
$section = $screen['meta']['backendsection'];
if (!isset($localMenu[$section])) {
$localMenu[$section] = [];
}
if (!isset($localMenu[$section]['metamodel_' . $metaModelName])) {
$localMenu[$section]['metamodel_' . $metaModelName] = ['tables' => []];
}
$localMenu[$section]['metamodel_' . $metaModelName]['callback'] = Module::class;
array_unshift($localMenu[$section]['metamodel_' . $metaModelName]['tables'], $metaModelName);
}
} | php | {
"resource": ""
} |
q244921 | UserListener.injectChildTables | validation | private function injectChildTables(&$localMenu)
{
$parented = $this->viewCombination->getParented();
$lastCount = count($parented);
while ($parented) {
foreach ($parented as $metaModelName => $child) {
foreach ($localMenu as $groupName => $modules) {
foreach ($modules as $moduleName => $module) {
if (isset($module['tables']) && in_array($child['meta']['ptable'], $module['tables'])) {
$localMenu[$groupName][$moduleName]['tables'][] = $metaModelName;
unset($parented[$metaModelName]);
break;
}
}
}
}
// If the dependencies can not be resolved any further, we give up here to prevent an endless loop.
if (count($parented) == $lastCount) {
break;
}
$lastCount = count($parented);
}
} | php | {
"resource": ""
} |
q244922 | HybridFilterBlock.getJumpTo | validation | public function getJumpTo()
{
if (!isset($this->arrJumpTo)) {
/** @var \Database\Result $page */
$page = $GLOBALS['objPage'];
$this->setJumpTo($page->row());
if ($this->metamodel_jumpTo) {
// Page to jump to when filter submit.
$statement = $this->getConnection()->prepare('SELECT id, alias FROM tl_page WHERE id=? LIMIT 0,1');
$statement->bindValue(1, $this->metamodel_jumpTo);
$statement->execute();
if ($statement->rowCount()) {
$this->setJumpTo($statement->fetch(\PDO::FETCH_ASSOC));
}
}
}
return $this->arrJumpTo;
} | php | {
"resource": ""
} |
q244923 | HybridFilterBlock.getFilterFactory | validation | private function getFilterFactory(): IFilterSettingFactory
{
if (null === $this->filterFactory) {
return $this->filterFactory = System::getContainer()->get('metamodels.filter_setting_factory');
}
return $this->filterFactory;
} | php | {
"resource": ""
} |
q244924 | HybridFilterBlock.getFilterUrlBuilder | validation | private function getFilterUrlBuilder(): FilterUrlBuilder
{
if (null === $this->filterUrlBuilder) {
return $this->filterUrlBuilder = System::getContainer()->get('metamodels.filter_url');
}
return $this->filterUrlBuilder;
} | php | {
"resource": ""
} |
q244925 | FilterBuilder.buildNativeSqlProcedure | validation | protected function buildNativeSqlProcedure(FilterBuilderSql $procedure, $children)
{
$skipped = array();
$metaModel = $this->getMetaModel();
$tableName = $metaModel->getTableName();
foreach ($children as $child) {
// If there is an attribute contained within this rule, skip it.
if (isset($child['property']) && $metaModel->hasAttribute($child['property'])) {
$skipped[] = $child;
continue;
}
// Try to parse the sub procedure and extract as much as possible.
if (('AND' === $child['operation']) || ('OR' === $child['operation'])) {
if (null === $child['children']) {
continue;
}
$subProcedure = new FilterBuilderSql($tableName, $child['operation'], $this->connection);
$subSkipped = $this->buildNativeSqlProcedure($subProcedure, $child['children']);
if (count($subSkipped) !== count($child['children'])) {
$procedure->addSubProcedure($subProcedure);
}
if (!empty($subSkipped)) {
$skipped += $subSkipped;
}
continue;
}
$procedure->addChild($child);
}
return $skipped;
} | php | {
"resource": ""
} |
q244926 | FilterBuilder.optimizedFilter | validation | protected function optimizedFilter($filterRule, $children, $operation)
{
$procedure = new FilterBuilderSql($this->getMetaModel()->getTableName(), $operation, $this->connection);
$skipped = $this->buildNativeSqlProcedure($procedure, $children);
if (!$procedure->isEmpty()) {
$filterRule->addChild($this->getMetaModel()->getEmptyFilter()->addFilterRule($procedure->build()));
}
return $skipped;
} | php | {
"resource": ""
} |
q244927 | FilterBuilder.getAndOrFilter | validation | protected function getAndOrFilter(IFilter $filter, $operation)
{
if (!$operation['children']) {
return;
}
if ($operation['operation'] == 'AND') {
$filterRule = new ConditionAnd();
} else {
$filterRule = new ConditionOr();
}
$filter->addFilterRule($filterRule);
$children = $this->optimizedFilter($filterRule, $operation['children'], $operation['operation']);
foreach ($children as $child) {
$subFilter = $this->getMetaModel()->getEmptyFilter();
$filterRule->addChild($subFilter);
$this->calculateSubfilter($child, $subFilter);
}
} | php | {
"resource": ""
} |
q244928 | FilterBuilder.getAttributeFromFilterOperation | validation | protected function getAttributeFromFilterOperation($operation)
{
$attribute = null;
if (!empty($operation['property'])) {
$attribute = $this->getMetaModel()->getAttribute($operation['property']);
}
if ($attribute === null) {
throw new \InvalidArgumentException('Attribute ' . $operation['property'] . ' not found.');
}
return $attribute;
} | php | {
"resource": ""
} |
q244929 | FilterBuilder.calculateSubfilter | validation | private function calculateSubfilter($operation, IFilter $filter)
{
if (!is_array($operation)) {
throw new \RuntimeException('Error Processing subfilter: ' . var_export($operation, true), 1);
}
switch ($operation['operation']) {
case 'AND':
case 'OR':
$this->getAndOrFilter($filter, $operation);
break;
case '=':
case '>':
case '<':
$this->getFilterForComparingOperator(
$this->getAttributeFromFilterOperation($operation),
$filter,
$operation
);
break;
case 'IN':
$this->getFilterForInList($filter, $operation);
break;
case 'LIKE':
$this->getFilterForLike(
$this->getAttributeFromFilterOperation($operation),
$filter,
$operation
);
break;
default:
throw new \RuntimeException(
'Error processing filter array - unknown operation ' . var_export($operation, true),
1
);
}
} | php | {
"resource": ""
} |
q244930 | CreateVariantButtonListener.createButton | validation | public function createButton(GetOperationButtonEvent $event)
{
if ('createvariant' !== $event->getCommand()->getName()) {
return;
}
/** @var Model $model */
$model = $event->getModel();
$metamodel = $model->getItem()->getMetaModel();
if (!$metamodel->hasVariants() || $model->getProperty('varbase') === '0') {
$event->setHtml('');
}
} | php | {
"resource": ""
} |
q244931 | CreateVariantButtonListener.handleCreateVariantAction | validation | public function handleCreateVariantAction(ActionEvent $event)
{
if (false === $this->scopeMatcher->currentScopeIsBackend()
|| 'createvariant' !== $event->getAction()->getName()) {
return;
}
$environment = $event->getEnvironment();
$view = $environment->getView();
$dataProvider = $environment->getDataProvider();
$inputProvider = $environment->getInputProvider();
$modelId = $inputProvider->hasParameter('id')
? ModelId::fromSerialized($inputProvider->getParameter('id'))
: null;
/** @var \MetaModels\DcGeneral\Data\Driver $dataProvider */
$model = $dataProvider
->createVariant(
$dataProvider
->getEmptyConfig()
->setId($modelId->getId())
);
if ($model == null) {
throw new \RuntimeException(sprintf(
'Could not find model with id %s for creating a variant.',
$modelId
));
}
$metaModel = $this->factory->getMetaModel($model->getProviderName());
if (!$metaModel || !$metaModel->hasVariants()) {
return;
}
$preFunction = function ($environment, $model) {
/** @var EnvironmentInterface $environment */
$copyEvent = new PreCreateModelEvent($environment, $model);
$environment->getEventDispatcher()->dispatch($copyEvent::NAME, $copyEvent);
};
$postFunction = function ($environment, $model) {
/** @var EnvironmentInterface $environment */
$copyEvent = new PostCreateModelEvent($environment, $model);
$environment->getEventDispatcher()->dispatch($copyEvent::NAME, $copyEvent);
};
if (!$view instanceof BackendViewInterface) {
throw new \InvalidArgumentException('Invalid view registered in environment.');
}
$editMask = new EditMask($view, $model, null, $preFunction, $postFunction, $this->breadcrumb($environment));
$event->setResponse($editMask->execute());
} | php | {
"resource": ""
} |
q244932 | CreateVariantButtonListener.presetVariantBase | validation | public function presetVariantBase(PreEditModelEvent $event)
{
$model = $event->getModel();
// Check of we have the driver from MetaModels. Only these request are from interest.
if (!$model instanceof Model) {
return;
}
// Get the item and check the context.
$nativeItem = $model->getItem();
$metaModel = $nativeItem->getMetaModel();
if ($metaModel->hasVariants() && (!$nativeItem->get('vargroup'))) {
$nativeItem->set('varbase', '1');
}
} | php | {
"resource": ""
} |
q244933 | CreateVariantButtonListener.breadcrumb | validation | protected function breadcrumb(EnvironmentInterface $environment)
{
$event = new GetBreadcrumbEvent($environment);
$environment->getEventDispatcher()->dispatch($event::NAME, $event);
$arrReturn = $event->getElements();
if (!is_array($arrReturn) || count($arrReturn) == 0) {
return null;
}
$GLOBALS['TL_CSS'][] = 'bundles/ccadcgeneral/css/generalBreadcrumb.css';
$objTemplate = new ContaoBackendViewTemplate('dcbe_general_breadcrumb');
$objTemplate->elements = $arrReturn;
return $objTemplate->parse();
} | php | {
"resource": ""
} |
q244934 | AttributeFactory.createAttribute | validation | public function createAttribute($information, $metaModel)
{
$event = new CreateAttributeEvent($information, $metaModel);
$this->eventDispatcher->dispatch(CreateAttributeEvent::NAME, $event);
if ($event->getAttribute()) {
return $event->getAttribute();
}
$factory = $this->getTypeFactory($information['type']);
if (!$factory) {
return null;
}
return $factory->createInstance($information, $metaModel);
} | php | {
"resource": ""
} |
q244935 | AbstractBreadcrumbListener.getBreadcrumb | validation | public function getBreadcrumb(GetBreadcrumbEvent $event)
{
$environment = $event->getEnvironment();
if (!$this->wantToHandle($event)) {
return;
}
$elements = $this->storeFactory->createStore();
$this->getBreadcrumbElements($environment, $elements);
$event->setElements($elements->getElements());
$event->stopPropagation();
} | php | {
"resource": ""
} |
q244936 | AbstractBreadcrumbListener.getBreadcrumbElements | validation | protected function getBreadcrumbElements(EnvironmentInterface $environment, BreadcrumbStore $elements)
{
if ($this->parent) {
$this->parent->getBreadcrumbElements($environment, $elements);
}
} | php | {
"resource": ""
} |
q244937 | AbstractBreadcrumbListener.extractIdFrom | validation | protected function extractIdFrom(EnvironmentInterface $environment, $parameterName = 'pid')
{
$parameter = $environment->getInputProvider()->getParameter($parameterName);
return ModelId::fromSerialized($parameter)->getId();
} | php | {
"resource": ""
} |
q244938 | PurgeListener.checkPurge | validation | public function checkPurge(AbstractModelAwareEvent $event)
{
$table = $event->getModel()->getProviderName();
if (($table == 'tl_metamodel') ||
($table == 'tl_metamodel_dca') ||
($table == 'tl_metamodel_dca_sortgroup') ||
($table == 'tl_metamodel_dcasetting') ||
($table == 'tl_metamodel_dcasetting_condition') ||
($table == 'tl_metamodel_attribute') ||
($table == 'tl_metamodel_filter') ||
($table == 'tl_metamodel_filtersetting') ||
($table == 'tl_metamodel_rendersettings') ||
($table == 'tl_metamodel_rendersetting') ||
($table == 'tl_metamodel_dca_combine')
) {
$this->purger->purge();
}
} | php | {
"resource": ""
} |
q244939 | Contao2BackendViewDefinitionBuilder.getOrCreateDefinition | validation | private function getOrCreateDefinition()
{
if ($this->container->hasDefinition(Contao2BackendViewDefinitionInterface::NAME)) {
$view = $this->container->getDefinition(Contao2BackendViewDefinitionInterface::NAME);
if (!$view instanceof Contao2BackendViewDefinitionInterface) {
throw new DcGeneralInvalidArgumentException(
'Configured BackendViewDefinition does not implement Contao2BackendViewDefinitionInterface.'
);
}
return $view;
}
$this->container->setDefinition(
Contao2BackendViewDefinitionInterface::NAME,
$view = new Contao2BackendViewDefinition()
);
return $view;
} | php | {
"resource": ""
} |
q244940 | Contao2BackendViewDefinitionBuilder.parseListing | validation | private function parseListing()
{
$listing = $this->definition->getListingConfig();
if (null === $listing->getRootLabel()) {
$listing->setRootLabel($this->metaModel->get('name'));
}
if (null === $listing->getRootIcon()) {
$listing->setRootIcon($this->iconBuilder->getBackendIcon($this->inputScreen['meta']['backendicon']));
}
$this->parseListSorting($listing);
$this->parseListLabel($listing);
$listing->setShowColumns((bool) $this->inputScreen['meta']['showColumns']);
} | php | {
"resource": ""
} |
q244941 | Contao2BackendViewDefinitionBuilder.handleSorting | validation | private function handleSorting(
$information,
GroupAndSortingDefinitionInterface $definition
) {
if ($information['ismanualsort']) {
$definition
->add()
->setManualSorting()
->setProperty('sorting')
->setSortingMode(GroupAndSortingInformationInterface::SORT_ASC);
return;
}
if ($information['col_name']) {
$definition
->add()
->setProperty($information['col_name'])
->setSortingMode($information['rendersort']);
}
} | php | {
"resource": ""
} |
q244942 | Contao2BackendViewDefinitionBuilder.convertRenderGroupType | validation | private function convertRenderGroupType($type)
{
$lookup = [
'char' => GroupAndSortingInformationInterface::GROUP_CHAR,
'digit' => GroupAndSortingInformationInterface::GROUP_DIGIT,
'day' => GroupAndSortingInformationInterface::GROUP_DAY,
'weekday' => GroupAndSortingInformationInterface::GROUP_WEEKDAY,
'week' => GroupAndSortingInformationInterface::GROUP_WEEK,
'month' => GroupAndSortingInformationInterface::GROUP_MONTH,
'year' => GroupAndSortingInformationInterface::GROUP_YEAR,
];
if (array_key_exists($type, $lookup)) {
return $lookup[$type];
}
return GroupAndSortingInformationInterface::GROUP_NONE;
} | php | {
"resource": ""
} |
q244943 | AbstractPaletteRestrictionListener.getLegend | validation | protected function getLegend($name, $palette, $prevLegend = null)
{
if (strpos($name, '+') === 0) {
$name = substr($name, 1);
}
if (!$palette->hasLegend($name)) {
$palette->addLegend(new Legend($name), $prevLegend);
}
return $palette->getLegend($name);
} | php | {
"resource": ""
} |
q244944 | AbstractPaletteRestrictionListener.getProperty | validation | protected function getProperty($name, $legend)
{
foreach ($legend->getProperties() as $property) {
if ($property->getName() === $name) {
return $property;
}
}
$property = new Property($name);
$legend->addProperty($property);
return $property;
} | php | {
"resource": ""
} |
q244945 | DuplicateModel.handle | validation | public function handle(PreDuplicateModelEvent $event)
{
$model = $event->getModel();
$metaModel = $this->factory->getMetaModel($model->getProviderName());
if (!$metaModel || !$metaModel->hasVariants()) {
return;
}
// If we have a varbase, reset the vargroup because we got a new id.
if ($model->getProperty('varbase') == 1) {
$model->setProperty('vargroup', null);
}
} | php | {
"resource": ""
} |
q244946 | AttributeAddingListener.handle | validation | public function handle(CreateMetaModelEvent $event)
{
if (null === $metaModel = $event->getMetaModel()) {
return;
}
foreach ($this->attributeFactory->createAttributesForMetaModel($metaModel) as $attribute) {
$metaModel->addAttribute($attribute);
}
} | php | {
"resource": ""
} |
q244947 | FrontendFilter.getMetaModelFrontendFilter | validation | public function getMetaModelFrontendFilter(HybridFilterBlock $objFilterConfig)
{
$this->objFilterConfig = $objFilterConfig;
$this->formId .= $this->objFilterConfig->id;
return $this->getFilters();
} | php | {
"resource": ""
} |
q244948 | FrontendFilter.renderWidget | validation | protected function renderWidget($widget, $filterOptions)
{
$filter = $widget;
$templateName = $filter['raw']['eval']['template'];
$template = new \FrontendTemplate($templateName ? $templateName : 'mm_filteritem_default');
$template->setData($filter);
$template->submit = $filterOptions->isAutoSubmit();
$filter['value'] = $template->parse();
return $filter;
} | php | {
"resource": ""
} |
q244949 | FrontendFilter.checkRedirect | validation | protected function checkRedirect($widgets, $wantedParameter, $allParameter)
{
// @codingStandardsIgnoreStart
@trigger_error(
sprintf('"%1$s" has been deprecated in favor of the new "FilterUrlBuilder"', __METHOD__),
E_USER_DEPRECATED
);
// @codingStandardsIgnoreEnd
// If we have POST data, we need to redirect now.
if (Input::post('FORM_SUBMIT') != $this->formId) {
return;
}
$redirectParameters = $allParameter['other'];
foreach ($wantedParameter as $widgetName) {
$filter = $widgets[$widgetName];
if ($filter['urlvalue'] !== null) {
$redirectParameters[$widgetName] = $filter['urlvalue'];
}
}
$filterUrl = new FilterUrl($this->objFilterConfig->getJumpTo(), [], $redirectParameters);
$dispatcher = $this->getDispatcher();
$dispatcher->dispatch(
ContaoEvents::CONTROLLER_REDIRECT,
new RedirectEvent($this->filterUrlBuilder->generate($filterUrl))
);
} | php | {
"resource": ""
} |
q244950 | FrontendFilter.getFrontendFilterOptions | validation | protected function getFrontendFilterOptions()
{
$objFrontendFilterOptions = new FrontendFilterOptions();
$objFrontendFilterOptions->setAutoSubmit($this->objFilterConfig->metamodel_fef_autosubmit ? true : false);
$objFrontendFilterOptions->setHideClearFilter(
$this->objFilterConfig->metamodel_fef_hideclearfilter ? true : false
);
$objFrontendFilterOptions->setShowCountValues(
$this->objFilterConfig->metamodel_available_values ? true : false
);
return $objFrontendFilterOptions;
} | php | {
"resource": ""
} |
q244951 | FrontendFilter.getFilters | validation | protected function getFilters()
{
$filterOptions = $this->getFrontendFilterOptions();
$jumpToInformation = $this->objFilterConfig->getJumpTo();
$filterSetting = $this->objFilterConfig->getFilterCollection();
$wantedNames = $this->getWantedNames();
$this->buildParameters(
$other = new FilterUrl($jumpToInformation),
$all = new FilterUrl($jumpToInformation),
$wantedNames
);
// DAMN Contao - we have to "mark" the keys in the Input class as used as we get an 404 otherwise.
foreach ($wantedNames as $name) {
if ($all->hasSlug($name)) {
Input::get($name);
}
}
$arrWidgets = $filterSetting->getParameterFilterWidgets(
$all->getSlugParameters(),
$jumpToInformation,
$filterOptions
);
// If we have POST data, we need to redirect now.
if (Input::post('FORM_SUBMIT') === $this->formId) {
foreach ($wantedNames as $widgetName) {
$filter = $arrWidgets[$widgetName];
if (null !== $filter['urlvalue']) {
$other->setSlug($widgetName, $filter['urlvalue']);
}
}
throw new RedirectResponseException($this->filterUrlBuilder->generate($other));
}
$renderedWidgets = [];
// Render the widgets through the filter templates.
foreach ($wantedNames as $strWidget) {
$renderedWidgets[$strWidget] = $this->renderWidget($arrWidgets[$strWidget], $filterOptions);
}
// Return filter data.
return [
'action' => $this->filterUrlBuilder->generate($other),
'formid' => $this->formId,
'filters' => $renderedWidgets,
'submit' => (
$filterOptions->isAutoSubmit()
? ''
: $GLOBALS['TL_LANG']['metamodels_frontendfilter']['submit']
)
];
} | php | {
"resource": ""
} |
q244952 | FrontendFilter.generateElement | validation | protected function generateElement($table, $content, $replace, $elementId)
{
$sql = sprintf('SELECT * FROM %s WHERE id=? AND type="metamodels_frontendclearall"', $table);
$statement = $this->connection->prepare($sql);
$statement->bindValue(1, $elementId);
$statement->execute();
$objDbResult = $statement->fetch(\PDO::FETCH_OBJ);
// Check if we have a existing module or ce element.
if ($objDbResult === false) {
return str_replace($replace, '', $content);
}
// Get instance and call generate function.
if ($table == 'tl_module') {
$objElement = new ModuleFilterClearAll($objDbResult);
} elseif ($table == 'tl_content') {
$objElement = new ContentElementFilterClearAll($objDbResult);
} else {
return str_replace($replace, '', $content);
}
return str_replace($replace, $objElement->generateReal(), $content);
} | php | {
"resource": ""
} |
q244953 | FrontendFilter.generateClearAll | validation | public function generateClearAll($strContent, $strTemplate)
{
if (substr($strTemplate, 0, 3) === 'fe_') {
if (preg_match_all(
'#\[\[\[metamodelfrontendfilterclearall::(ce|mod)::([^\]]*)\]\]\]#',
$strContent,
$arrMatches,
PREG_SET_ORDER
)) {
foreach ($arrMatches as $arrMatch) {
switch ($arrMatch[1]) {
case 'ce':
$strContent = $this->generateContentElement($strContent, $arrMatch[0], $arrMatch[2]);
break;
case 'mod':
$strContent = $this->generateModule($strContent, $arrMatch[0], $arrMatch[2]);
break;
default:
throw new \RuntimeException('Unexpected element determinator encountered: ' . $arrMatch[1]);
}
}
}
}
return $strContent;
} | php | {
"resource": ""
} |
q244954 | AbstractFilterSettingTypeFactory.isNestedType | validation | public function isNestedType()
{
if (!isset($this->isNestedType)) {
$this->isNestedType = in_array(
'MetaModels\Filter\Setting\IWithChildren',
class_implements($this->typeClass, true)
);
}
return $this->isNestedType;
} | php | {
"resource": ""
} |
q244955 | AbstractFilterSettingTypeFactory.allowAttributeTypes | validation | protected function allowAttributeTypes($initialType1toN = null)
{
if (is_array($initialType1toN)) {
$this->attributeTypes = $initialType1toN;
} else {
$this->attributeTypes = func_get_args();
}
return $this;
} | php | {
"resource": ""
} |
q244956 | AbstractFilterSettingTypeFactory.addKnownAttributeType | validation | public function addKnownAttributeType($typeName)
{
if (!is_array($this->attributeTypes)) {
throw new \LogicException('Filter setting ' . $this->typeClass . ' can not handle attributes.');
}
$this->attributeTypes[$typeName] = $typeName;
return $this;
} | php | {
"resource": ""
} |
q244957 | TypeOptionsListener.handle | validation | public function handle(GetPropertyOptionsEvent $event)
{
if (!$this->wantToHandle($event)) {
return;
}
$options = [];
foreach ($this->conditionFactory->getTypeNames() as $condition) {
$options[$condition] = $this->translator->trans(
'tl_metamodel_dcasetting_condition.conditionnames.' . $condition,
[],
'contao_tl_metamodel_dcasetting_condition'
);
}
$event->setOptions($options);
} | php | {
"resource": ""
} |
q244958 | ColumnExistsException.withName | validation | public static function withName($columnName, $tableName, $code = 0, $previous = null)
{
return new static(
sprintf('Column "%s" already exists on table "%s', $columnName, $tableName),
$code,
$previous
);
} | php | {
"resource": ""
} |
q244959 | AbstractListener.getMetaModelFromModel | validation | protected function getMetaModelFromModel(ModelInterface $model)
{
if (!(($model->getProviderName() == 'tl_metamodel_dca_sortgroup') && $model->getProperty('pid'))) {
throw new DcGeneralInvalidArgumentException(
sprintf(
'Model must originate from tl_metamodel_dca_sortgroup and be saved, this one originates from %s ' .
'and has pid %s',
$model->getProviderName(),
$model->getProperty('pid')
)
);
}
$metaModelId = $this->connection->createQueryBuilder()
->select('pid')
->from('tl_metamodel_dca')
->where('id=:id')
->setParameter('id', $model->getProperty('pid'))
->execute()
->fetchColumn();
$tableName = $this->factory->translateIdToMetaModelName($metaModelId);
return $this->factory->getMetaModel($tableName);
} | php | {
"resource": ""
} |
q244960 | GetAttributeTypeListener.wantToHandle | validation | protected function wantToHandle(AbstractEnvironmentAwareEvent $event)
{
/** @var GetPropertyOptionsEvent $event */
if (!parent::wantToHandle($event)) {
return false;
}
if ($event->getPropertyName() !== 'type') {
return false;
}
$request = $this->requestStack->getCurrentRequest();
if ($request->request->get('act', null) === 'select' && !$event->getModel()->getId()) {
return false;
}
return true;
} | php | {
"resource": ""
} |
q244961 | MultiTextWidget.validator | validation | protected function validator($varInput)
{
if (is_array($varInput)) {
$value = array();
foreach ($varInput as $key => $input) {
$value[$key] = parent::validator($input);
}
return $value;
}
return parent::validator(trim($varInput));
} | php | {
"resource": ""
} |
q244962 | TableUpdatingListener.handleDelete | validation | public function handleDelete(PreDeleteModelEvent $event)
{
if (!$this->wantToHandle($event)) {
return;
}
try {
$this->tableManipulator->checkTableExists($tableName = $event->getModel()->getProperty('tableName'));
} catch (\Exception $exception) {
// Exit if table does not exist.
return;
}
$this->tableManipulator->deleteTable($tableName);
} | php | {
"resource": ""
} |
q244963 | TableUpdatingListener.handleUpdate | validation | public function handleUpdate(PostPersistModelEvent $event)
{
if (!$this->wantToHandle($event)) {
return;
}
$old = $event->getOriginalModel();
$new = $event->getModel();
$oldTable = $old ? $old->getProperty('tableName') : null;
$newTable = $new->getProperty('tableName');
// Table name changed?
if ($oldTable !== $newTable) {
if (!empty($oldTable)) {
$this->tableManipulator->renameTable($oldTable, $newTable);
} else {
$this->tableManipulator->createTable($newTable);
}
}
$this->tableManipulator->setVariantSupport($newTable, $new->getProperty('varsupport'));
} | php | {
"resource": ""
} |
q244964 | CollectMetaModelTableNamesEvent.addMetaModelNames | validation | public function addMetaModelNames($metaModelNames)
{
$this->metaModelNames = array_unique(array_merge($this->metaModelNames, $metaModelNames));
return $this;
} | php | {
"resource": ""
} |
q244965 | MetaModelsCoreExtension.buildCacheService | validation | private function buildCacheService(ContainerBuilder $container, array $config)
{
// if cache disabled, swap it out with the dummy cache.
if (!$config['enable_cache']) {
$cache = $container->getDefinition('metamodels.cache');
$cache->setClass(ArrayCache::class);
$cache->setArguments([]);
$container->setParameter('metamodels.cache_dir', null);
return;
}
$container->setParameter('metamodels.cache_dir', $config['cache_dir']);
} | php | {
"resource": ""
} |
q244966 | MetaModelsCoreExtension.buildPickerService | validation | private function buildPickerService(ContainerBuilder $container)
{
$pickerService = $container->getDefinition('metamodels.controller.picker');
$configs = $pickerService->getArgument(2);
// Selectable styles in the palette tl_class definitions.
$configs['PALETTE_STYLE_PICKER'][] = ['cssclass' => 'w50'];
$configs['PALETTE_STYLE_PICKER'][] = ['cssclass' => 'w50x'];
$configs['PALETTE_STYLE_PICKER'][] = ['cssclass' => 'clr'];
$configs['PALETTE_STYLE_PICKER'][] = ['cssclass' => 'clx'];
$configs['PALETTE_STYLE_PICKER'][] = ['cssclass' => 'long'];
$configs['PALETTE_STYLE_PICKER'][] = ['cssclass' => 'wizard'];
$configs['PALETTE_STYLE_PICKER'][] = ['cssclass' => 'm12'];
// Selectable panels in the palette panelLayout definitions.
$configs['PALETTE_PANEL_PICKER'][] = ['cssclass' => 'search'];
$configs['PALETTE_PANEL_PICKER'][] = ['cssclass' => 'sort'];
$configs['PALETTE_PANEL_PICKER'][] = ['cssclass' => 'filter'];
$configs['PALETTE_PANEL_PICKER'][] = ['cssclass' => 'limit'];
$pickerService->setArgument(2, $configs);
} | php | {
"resource": ""
} |
q244967 | SimpleQuery.createFromQueryBuilder | validation | public static function createFromQueryBuilder(QueryBuilder $builder, $columnName = 'id')
{
return new self(
$builder->getSQL(),
$builder->getParameters(),
$columnName,
$builder->getConnection(),
$builder->getParameterTypes()
);
} | php | {
"resource": ""
} |
q244968 | SimpleQuery.sanitizeConnection | validation | private function sanitizeConnection($connection)
{
if ($connection instanceof Connection) {
return $connection;
}
// BC layer - we used to accept a Contao database instance here.
if ($connection instanceof Database) {
// @codingStandardsIgnoreStart
@trigger_error(
'"' . __METHOD__ . '" now accepts doctrine instances - ' .
'passing Contao database instances is deprecated.',
E_USER_DEPRECATED
);
// @codingStandardsIgnoreEnd
$reflection = new \ReflectionProperty(Database::class, 'resConnection');
$reflection->setAccessible(true);
return $reflection->getValue($connection);
}
if (null === $connection) {
// @codingStandardsIgnoreStart
@trigger_error(
'You should pass a doctrine database connection to "' . __METHOD__ . '".',
E_USER_DEPRECATED
);
// @codingStandardsIgnoreEnd
$connection = System::getContainer()->get('database_connection');
}
if (!($connection instanceof Connection)) {
throw new \RuntimeException('Could not obtain doctrine connection.');
}
return $connection;
} | php | {
"resource": ""
} |
q244969 | MetaModel.tryUnserialize | validation | protected function tryUnserialize($value)
{
if (!is_array($value)
&& 0 === strpos($value, 'a:')
&& is_array($unSerialized = unserialize($value, ['allowed_classes' => false]))) {
return $unSerialized;
}
return $value;
} | php | {
"resource": ""
} |
q244970 | MetaModel.getAttributeImplementing | validation | protected function getAttributeImplementing($interface)
{
$result = array();
foreach ($this->getAttributes() as $colName => $attribute) {
if ($attribute instanceof $interface) {
$result[$colName] = $attribute;
}
}
return $result;
} | php | {
"resource": ""
} |
q244971 | MetaModel.getMatchingIds | validation | protected function getMatchingIds($objFilter)
{
if ($objFilter) {
$arrFilteredIds = $objFilter->getMatchingIds();
if ($arrFilteredIds !== null) {
return $arrFilteredIds;
}
}
// Either no filter object or all ids allowed => return all ids.
// if no id filter is passed, we assume all ids are provided.
return $this->getConnection()->createQueryBuilder()
->select('id')
->from($this->getTableName())
->execute()
->fetchAll(\PDO::FETCH_COLUMN);
} | php | {
"resource": ""
} |
q244972 | MetaModel.fetchRows | validation | protected function fetchRows($arrIds, $arrAttrOnly = array())
{
/** @var QueryBuilder $builder */
$builder = $this->getConnection()->createQueryBuilder();
$query = $builder
->select('*')
->from($this->getTableName())
->where($builder->expr()->in('id', ':values'))
->setParameter('values', $arrIds, Connection::PARAM_STR_ARRAY)
->orderBy('FIELD(id, :values)')
->execute();
// If we have an attribute restriction, make sure we keep the system columns. See #196.
if ($arrAttrOnly) {
$arrAttrOnly = array_merge($this->systemColumns, $arrAttrOnly);
}
$result = [];
while ($row = $query->fetch(\PDO::FETCH_ASSOC)) {
$data = [];
foreach ($row as $attribute => $value) {
if ((!$arrAttrOnly) || (in_array($attribute, $arrAttrOnly, true))) {
$data[$attribute] = $value;
}
}
$result[$row['id']] = $data;
}
return $result;
} | php | {
"resource": ""
} |
q244973 | MetaModel.copyFilter | validation | protected function copyFilter($objFilter)
{
if ($objFilter) {
$objNewFilter = $objFilter->createCopy();
} else {
$objNewFilter = $this->getEmptyFilter();
}
return $objNewFilter;
} | php | {
"resource": ""
} |
q244974 | MetaModel.getAttributeByNames | validation | protected function getAttributeByNames($attrNames = array())
{
if (empty($attrNames)) {
return $this->arrAttributes;
}
$result = array();
foreach ($attrNames as $attributeName) {
$result[$attributeName] = $this->arrAttributes[$attributeName];
}
return $result;
} | php | {
"resource": ""
} |
q244975 | MetaModel.saveSimpleColumn | validation | protected function saveSimpleColumn($strColumn, $arrIds, $varData)
{
if (is_array($varData)) {
$varData = serialize($varData);
}
$builder = $this->getConnection()->createQueryBuilder();
$builder
->update($this->getTableName(), 'v2')
->set('v2.' . $strColumn, is_array($varData) ? serialize($varData) : $varData)
->where($builder->expr()->in('v2.id', ':ids'))
->setParameter('ids', $arrIds, Connection::PARAM_STR_ARRAY)
->execute();
} | php | {
"resource": ""
} |
q244976 | MetaModel.saveAttribute | validation | protected function saveAttribute($objAttribute, $arrIds, $varData, $strLangCode)
{
// Call the serializeData for all simple attributes.
if ($this->isSimpleAttribute($objAttribute)) {
/** @var \MetaModels\Attribute\ISimple $objAttribute */
$varData = $objAttribute->serializeData($varData);
}
$arrData = array();
foreach ($arrIds as $intId) {
$arrData[$intId] = $varData;
}
// Check for translated fields first, then for complex and save as simple then.
if ($strLangCode && $this->isTranslatedAttribute($objAttribute)) {
/** @var ITranslated $objAttribute */
$objAttribute->setTranslatedDataFor($arrData, $strLangCode);
} elseif ($this->isComplexAttribute($objAttribute)) {
// Complex saving.
$objAttribute->setDataFor($arrData);
} elseif ($this->isSimpleAttribute($objAttribute)) {
$objAttribute->setDataFor($arrData);
} else {
throw new \RuntimeException(
'Unknown attribute type, can not save. Interfaces implemented: ' .
implode(', ', class_implements($objAttribute))
);
}
} | php | {
"resource": ""
} |
q244977 | MetaModel.updateVariants | validation | protected function updateVariants($item, $activeLanguage, $allIds, $baseAttributes = false)
{
foreach ($this->getAttributes() as $strAttributeId => $objAttribute) {
// Skip unset attributes.
if (!$item->isAttributeSet($objAttribute->getColName())) {
continue;
}
if (!$baseAttributes && $item->isVariant() && !($objAttribute->get('isvariant'))) {
// Skip base attribute.
continue;
}
if ($item->isVariantBase() && !($objAttribute->get('isvariant'))) {
// We have to override in variants.
$arrIds = $allIds;
} else {
$arrIds = array($item->get('id'));
}
$this->saveAttribute($objAttribute, $arrIds, $item->get($strAttributeId), $activeLanguage);
}
} | php | {
"resource": ""
} |
q244978 | MetaModel.createNewItem | validation | protected function createNewItem($item)
{
$data = ['tstamp' => $item->get('tstamp')];
$isNewItem = false;
if ($this->hasVariants()) {
// No variant group is given, so we have a complete new base item this should be a workaround for these
// values should be set by the GeneralDataMetaModel or whoever is calling this method.
if ($item->get('vargroup') === null) {
$item->set('varbase', '1');
$item->set('vargroup', '0');
$isNewItem = true;
}
$data['varbase'] = $item->get('varbase');
$data['vargroup'] = $item->get('vargroup');
}
$connection = $this->getConnection();
$builder = $connection->createQueryBuilder();
$parameters = [];
foreach (array_keys($data) as $key) {
$parameters[$key] = ':' . $key;
}
$builder
->insert($this->getTableName())
->values($parameters)
->setParameters($data)
->execute();
$item->set('id', $connection->lastInsertId());
// Add the variant group equal to the id.
if ($isNewItem) {
$this->saveSimpleColumn('vargroup', [$item->get('id')], $item->get('id'));
}
} | php | {
"resource": ""
} |
q244979 | MetaModel.getConnection | validation | private function getConnection()
{
if ($this->connection) {
return $this->connection;
}
$reflection = new \ReflectionProperty(\Contao\Database::class, 'resConnection');
$reflection->setAccessible(true);
return $this->connection = $reflection->getValue($this->getDatabase());
} | php | {
"resource": ""
} |
q244980 | MetaModel.saveBaseColumns | validation | private function saveBaseColumns(IItem $item, $timestamp)
{
$isNew = false;
$item->set('tstamp', $timestamp);
if (!$item->get('id')) {
$isNew = true;
$this->createNewItem($item);
}
// Update system columns.
if (null !== $item->get('pid')) {
$this->saveSimpleColumn('pid', [$item->get('id')], $item->get('pid'));
}
if (null !== $item->get('sorting')) {
$this->saveSimpleColumn('sorting', [$item->get('id')], $item->get('sorting'));
}
$this->saveSimpleColumn('tstamp', [$item->get('id')], $item->get('tstamp'));
return $isNew;
} | php | {
"resource": ""
} |
q244981 | ViewCombinationBuilder.getCombinationsForUser | validation | public function getCombinationsForUser($userGroups, $userType)
{
$userType = strtolower($userType);
if ('fe' !== $userType && 'be' !== $userType) {
throw new \InvalidArgumentException('Unknown user type: ' . $userType);
}
return $this->getCombinationsFromDatabase($userGroups, $userType);
} | php | {
"resource": ""
} |
q244982 | FilterSettingTypeRendererCore.getLabelParameters | validation | protected function getLabelParameters(EnvironmentInterface $environment, ModelInterface $model)
{
if ($model->getProperty('type') == 'simplelookup') {
return $this->getLabelParametersWithAttributeAndUrlParam($environment, $model);
}
return $this->getLabelParametersNormal($environment, $model);
} | php | {
"resource": ""
} |
q244983 | Driver.delete | validation | public function delete($varItem)
{
// Determine the id.
if (is_object($varItem) && ($varItem instanceof Model)) {
$objModelItem = $varItem->getItem();
} else {
$objModelItem = $this->getMetaModel()->findById($varItem);
}
if ($objModelItem) {
$this->getMetaModel()->delete($objModelItem);
}
} | php | {
"resource": ""
} |
q244984 | Driver.setLanguage | validation | protected function setLanguage($language = '')
{
$previousLanguage = $GLOBALS['TL_LANGUAGE'];
if (!empty($language) && ($GLOBALS['TL_LANGUAGE'] !== $language)) {
$GLOBALS['TL_LANGUAGE'] = $language;
}
return $previousLanguage;
} | php | {
"resource": ""
} |
q244985 | Driver.getMetaModel | validation | protected function getMetaModel()
{
if (!$this->metaModel) {
if ($this->metaModel === null) {
throw new \RuntimeException('No MetaModel instance set for ' . $this->strTable);
}
}
return $this->metaModel;
} | php | {
"resource": ""
} |
q244986 | Driver.fetch | validation | public function fetch(ConfigInterface $objConfig)
{
$backupLanguage = $this->setLanguage($this->getCurrentLanguage());
if ($objConfig->getId() !== null) {
$modelId = $objConfig->getId();
} else {
$filter = $this->prepareFilter($objConfig);
$ids = $this->getIdsFromFilter($filter, $objConfig);
$modelId = reset($ids);
}
$objItem = $modelId ? $this->getMetaModel()->findById($modelId, $objConfig->getFields() ?: array()) : null;
$this->setLanguage($backupLanguage);
if (!$objItem) {
return null;
}
return new Model($objItem);
} | php | {
"resource": ""
} |
q244987 | Driver.setBaseConfig | validation | public function setBaseConfig(array $arrConfig)
{
if (!$arrConfig['source']) {
throw new \RuntimeException('Missing table name.');
}
$this->strTable = $arrConfig['source'];
$this->metaModel = $arrConfig['metaModel'];
} | php | {
"resource": ""
} |
q244988 | Driver.extractSorting | validation | protected function extractSorting($config)
{
$sorting = $config->getSorting();
$sortBy = key($sorting);
$sortDir = current($sorting) ?: DCGE::MODEL_SORTING_ASC;
return array($sortBy, $sortDir);
} | php | {
"resource": ""
} |
q244989 | Driver.getIdsFromFilter | validation | protected function getIdsFromFilter($filter, $config)
{
$sorting = $this->extractSorting($config);
return $this->getMetaModel()->getIdsFromFilter(
$filter,
$sorting[0],
$config->getStart(),
$config->getAmount(),
strtoupper($sorting[1])
);
} | php | {
"resource": ""
} |
q244990 | Driver.getItemsFromFilter | validation | protected function getItemsFromFilter($filter, $config)
{
$sorting = $this->extractSorting($config);
return $this->getMetaModel()->findByFilter(
$filter,
$sorting[0],
$config->getStart(),
$config->getAmount(),
strtoupper($sorting[1]),
$config->getFields() ?: array()
);
} | php | {
"resource": ""
} |
q244991 | Driver.getFilterOptions | validation | public function getFilterOptions(ConfigInterface $objConfig)
{
$arrProperties = $objConfig->getFields();
if (count($arrProperties) <> 1) {
throw new \RuntimeException('objConfig must contain exactly one property to be retrieved.');
}
$objFilter = $this->prepareFilter($objConfig);
$arrValues = $this
->getMetaModel()
->getAttribute($arrProperties[0])
->getFilterOptions($objFilter->getMatchingIds(), true);
$objCollection = new DefaultFilterOptionCollection();
foreach ($arrValues as $strKey => $strValue) {
$objCollection->add($strKey, $strValue);
}
return $objCollection;
} | php | {
"resource": ""
} |
q244992 | Driver.isUniqueValue | validation | public function isUniqueValue($strField, $varNew, $intId = null)
{
$attribute = $this->getMetaModel()->getAttribute($strField);
if ($attribute) {
$matchingIds = $this
->prepareFilter(
$this->getEmptyConfig()->setFilter(
array(
array(
'operation' => '=',
'property' => $attribute->getColName(),
'value' => $varNew
)
)
)
)
->getMatchingIds();
return (count($matchingIds) == 0) || ($matchingIds == array($intId));
}
return false;
} | php | {
"resource": ""
} |
q244993 | Driver.resetFallback | validation | public function resetFallback($strField)
{
// @codingStandardsIgnoreStart
@trigger_error(__CLASS__ . '::' . __METHOD__ . ' is deprecated - handle resetting manually', E_USER_DEPRECATED);
// @codingStandardsIgnoreEnd
$metaModel = $this->getMetaModel();
$attribute = $metaModel->getAttribute($strField);
$ids = $metaModel->getIdsFromFilter(null);
if ($attribute instanceof IComplex) {
$attribute->unsetDataFor($ids);
}
if ($attribute instanceof ITranslated) {
$attribute->unsetValueFor($ids, $this->getCurrentLanguage());
}
if ($attribute instanceof IAttribute) {
$data = array();
foreach ($ids as $id) {
$data[$id] = null;
}
$attribute->setDataFor($data);
}
throw new \RuntimeException('Unknown attribute or type ' . $strField);
} | php | {
"resource": ""
} |
q244994 | Driver.save | validation | public function save(ModelInterface $objItem, $timestamp = null)
{
if (null === $timestamp) {
// @codingStandardsIgnoreStart
@\trigger_error(
'Not passing a timestamp has been deprecated and will cause an error in MetaModels 3',
E_USER_DEPRECATED
);
// @codingStandardsIgnoreEnd
}
if ($objItem instanceof Model) {
$backupLanguage = $this->setLanguage($this->getCurrentLanguage());
$objItem->getItem()->save($timestamp);
$this->setLanguage($backupLanguage);
return $objItem;
}
throw new \RuntimeException('ERROR: incompatible object passed to GeneralDataMetaModel::save()');
} | php | {
"resource": ""
} |
q244995 | Driver.saveEach | validation | public function saveEach(CollectionInterface $objItems, $timestamp = 0)
{
if (null === $timestamp) {
// @codingStandardsIgnoreStart
@\trigger_error(
'Not passing a timestamp has been deprecated and will cause an error in MetaModels 3',
E_USER_DEPRECATED
);
// @codingStandardsIgnoreEnd
}
foreach ($objItems as $objItem) {
$this->save($objItem, $timestamp);
}
} | php | {
"resource": ""
} |
q244996 | Driver.sameModels | validation | public function sameModels($objModel1, $objModel2)
{
if (!($objModel1 instanceof Model && $objModel2 instanceof Model)) {
throw new \InvalidArgumentException('Passed models are not valid.');
}
$objNative1 = $objModel1->getItem();
$objNative2 = $objModel2->getItem();
if ($objNative1->getMetaModel() === $objNative2->getMetaModel()) {
return true;
}
foreach ($objNative1->getMetaModel()->getAttributes() as $objAttribute) {
if ($objNative1->get($objAttribute->getColName()) != $objNative2->get($objAttribute->getColName())) {
return false;
}
}
return true;
} | php | {
"resource": ""
} |
q244997 | Driver.createVariant | validation | public function createVariant(ConfigInterface $objConfig)
{
$objItem = $this->getMetaModel()->findById($objConfig->getId())->varCopy();
if (!$objItem) {
return null;
}
$model = new Model($objItem);
$model->setMeta($model::IS_CHANGED, true);
return $model;
} | php | {
"resource": ""
} |
q244998 | NameAndDescriptionListener.decodeValue | validation | public function decodeValue(DecodePropertyValueForWidgetEvent $event)
{
if (!($this->wantToHandle($event) && \in_array($event->getProperty(), ['name', 'description']))) {
return;
}
$metaModel = $this->getMetaModelByModelPid($event->getModel());
$values = Helper::decodeLangArray($event->getValue(), $metaModel);
$event->setValue(unserialize($values, ['allowed_classes' => false]));
} | php | {
"resource": ""
} |
q244999 | NameAndDescriptionListener.encodeValue | validation | public function encodeValue(EncodePropertyValueFromWidgetEvent $event)
{
if (!($this->wantToHandle($event) && \in_array($event->getProperty(), ['name', 'description']))) {
return;
}
$metaModel = $this->getMetaModelByModelPid($event->getModel());
$values = Helper::encodeLangArray($event->getValue(), $metaModel);
$event->setValue($values);
} | php | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.