_id
stringlengths 2
7
| title
stringlengths 3
151
| partition
stringclasses 3
values | text
stringlengths 83
13k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q1300 | MediaController.deleteDirectory | train | protected function deleteDirectory(Request $request)
{
try {
$dir = $request->input('s');
Storage::deleteDirectory($dir);
return $this->notifySuccess($dir . ' successfully deleted!');
} catch (\ErrorException $e) {
return $this->notifyError($e->getMessage());
}
} | php | {
"resource": ""
} |
q1301 | MediaController.deleteFile | train | protected function deleteFile(Request $request)
{
try {
$file = $request->input('s');
Storage::delete($file);
return $this->notifySuccess($file . ' successfully deleted!');
} catch (\ErrorException $e) {
return $this->notifyError($e->getMessage());
}
} | php | {
"resource": ""
} |
q1302 | ExtensionsController.destroy | train | public function destroy($id)
{
$extension = $this->repository->findOrFail($id);
if ($extension->protected) {
return $this->notifyError(trans('cms::extension.protected'));
}
if ($this->repository->uninstall($id)) {
flash()->success(trans('cms::extension.deleted', compact('id')));
} else {
flash()->error(trans('cms::extension.error', compact('id')));
}
return back();
} | php | {
"resource": ""
} |
q1303 | Responder.payload | train | public function payload($payload, $format = '', $container = 'data')
{
$class = $this->getFormatClass($format);
return $this->generate($payload, new $class, $container);
} | php | {
"resource": ""
} |
q1304 | Responder.registerFormat | train | public function registerFormat($format, $class)
{
if ( ! class_exists($class)) {
throw new \InvalidArgumentException("Responder formatter class {$class} not found.");
}
if ( ! is_a($class, 'Nathanmac\Utilities\Responder\Formats\FormatInterface', true)) {
throw new \InvalidArgumentException('Responder formatters must implement the Nathanmac\Utilities\Responder\Formats\FormatInterface interface.');
}
$this->supported_formats[$format] = $class;
return $this;
} | php | {
"resource": ""
} |
q1305 | RedirectComponent.handle | train | public function handle(ComponentContext $componentContext)
{
$routingMatchResults = $componentContext->getParameter(RoutingComponent::class, 'matchResults');
if ($routingMatchResults !== NULL) {
return;
}
$httpRequest = $componentContext->getHttpRequest();
$response = $this->redirectService->buildResponseIfApplicable($httpRequest);
if ($response !== null) {
$componentContext->replaceHttpResponse($response);
$componentContext->setParameter(ComponentChain::class, 'cancel', true);
}
} | php | {
"resource": ""
} |
q1306 | Menu.category | train | public function category()
{
$category = $this->param('category_id', 0);
$categoryId = explode(':', $category)[0];
return Category::query()->findOrNew($categoryId);
} | php | {
"resource": ""
} |
q1307 | Menu.hasWidget | train | public function hasWidget($widget)
{
if ($widget instanceof Model) {
$widget = $widget->id;
}
return $this->widgets()->where('widget_id', $widget)->exists();
} | php | {
"resource": ""
} |
q1308 | WidgetPresenter.template | train | public function template()
{
return $this->entity->template === 'custom' ? $this->entity->custom_template : $this->entity->template;
} | php | {
"resource": ""
} |
q1309 | WidgetPresenter.class | train | public function class()
{
/** @var \Yajra\CMS\Repositories\Extension\Repository $repository */
$repository = app('extensions');
$extension = $repository->findOrFail($this->entity->extension_id);
return $extension->param('class');
} | php | {
"resource": ""
} |
q1310 | PermissionsController.create | train | public function create()
{
$permission = new Permission;
$permission->resource = 'System';
$roles = Role::all();
return view('administrator.permissions.create', compact('permission', 'roles'));
} | php | {
"resource": ""
} |
q1311 | PermissionsController.store | train | public function store()
{
$this->validate($this->request, [
'name' => 'required',
'resource' => 'required|alpha_num',
'slug' => 'required|unique:permissions,slug',
]);
$permission = Permission::create($this->request->all());
$permission->syncRoles($this->request->get('roles', []));
return redirect()->route('administrator.permissions.index');
} | php | {
"resource": ""
} |
q1312 | PermissionsController.storeResource | train | public function storeResource()
{
$this->validate($this->request, [
'resource' => 'required|alpha_num',
]);
$permissions = Permission::createResource($this->request->resource);
foreach ($permissions as $permission) {
$permission->syncRoles($this->request->get('roles', []));
}
return redirect()->route('administrator.permissions.index');
} | php | {
"resource": ""
} |
q1313 | PermissionsController.update | train | public function update(Permission $permission)
{
$this->validate($this->request, [
'name' => 'required',
'resource' => 'required|alpha_num',
'slug' => 'required|unique:permissions,slug,' . $permission->id,
]);
$permission->name = $this->request->get('name');
$permission->resource = $this->request->get('resource');
if (! $permission->system) {
$permission->slug = $this->request->get('slug');
}
$permission->save();
$permission->syncRoles($this->request->get('roles', []));
return redirect()->route('administrator.permissions.index');
} | php | {
"resource": ""
} |
q1314 | PermissionsController.destroy | train | public function destroy(Permission $permission)
{
if (! $permission->system) {
try {
$permission->delete();
return $this->notifySuccess('Permission successfully deleted!');
} catch (QueryException $e) {
return $this->notifyError($e->getMessage());
}
}
return $this->notifyError('System permission is protected and cannot be deleted!');
} | php | {
"resource": ""
} |
q1315 | Number.fatorVencimento | train | public static function fatorVencimento(\DateTime $data)
{
$dataBase = new \DateTime("1997-10-07");
return (int)$data->diff($dataBase, true)->format('%r%a');
} | php | {
"resource": ""
} |
q1316 | UsersController.index | train | public function index(UsersDataTable $dataTable)
{
$roles = $this->role->pluck('name', 'id');
return $dataTable->render('administrator.users.index', compact('roles'));
} | php | {
"resource": ""
} |
q1317 | UsersController.create | train | public function create()
{
$roles = $this->getAllowedRoles();
$selectedRoles = $this->request->old('roles');
$user = new User([
'blocked' => 0,
'confirmed' => 1,
]);
return view('administrator.users.create', compact('user', 'roles', 'selectedRoles'));
} | php | {
"resource": ""
} |
q1318 | UsersController.getAllowedRoles | train | protected function getAllowedRoles()
{
if ($this->request->user('administrator')->isRole('super-administrator')) {
$roles = $this->role->newQuery()->get();
} else {
$roles = $this->role->newQuery()->where('slug', '!=', 'super-administrator')->get();
}
return $roles->pluck('name', 'id');
} | php | {
"resource": ""
} |
q1319 | UsersController.store | train | public function store(StoreUserValidator $request)
{
$user = new User($request->all());
$user->password = bcrypt($request->get('password'));
$user->is_activated = $request->get('is_activated', false);
$user->is_blocked = $request->get('is_blocked', false);
$user->is_admin = $request->get('is_admin', false);
$user->save();
$user->syncRoles($request->get('roles'));
event(new UserWasCreated($user));
flash()->success('User ' . $user->first_name . 'successfully created!');
return redirect()->route('administrator.users.index');
} | php | {
"resource": ""
} |
q1320 | UsersController.edit | train | public function edit(User $user)
{
$roles = $this->getAllowedRoles();
$selectedRoles = $user->roles()->pluck('roles.id');
return view('administrator.users.edit', compact('user', 'roles', 'selectedRoles'));
} | php | {
"resource": ""
} |
q1321 | UsersController.destroy | train | public function destroy(User $user, $force = false)
{
if ($user->id <> auth('administrator')->id()) {
try {
if ($force) {
$user->forceDelete();
} else {
$user->delete();
}
return $this->notifySuccess('User successfully deleted!');
} catch (QueryException $e) {
return $this->notifyError($e->getMessage());
}
}
return $this->notifyError('You cannot delete your own record!');
} | php | {
"resource": ""
} |
q1322 | UsersController.ban | train | public function ban(User $user)
{
$user->is_blocked = ! $user->is_blocked;
$user->save();
if ($user->is_blocked) {
return $this->notifySuccess('User ' . $user->name . ' blocked!');
} else {
return $this->notifySuccess('User ' . $user->name . ' un-blocked!');
}
} | php | {
"resource": ""
} |
q1323 | UsersController.activate | train | public function activate(User $user)
{
$user->is_activated = ! $user->is_activated;
$user->save();
if ($user->is_activated) {
return $this->notifySuccess('User ' . $user->name . ' activated!');
} else {
return $this->notifySuccess('User ' . $user->name . ' deactivated!');
}
} | php | {
"resource": ""
} |
q1324 | SiteSummaryExtension.updateAlerts | train | public function updateAlerts(&$alerts)
{
$securityWarnings = $this->owner->sourceRecords()->filter('SecurityAlerts.ID:GreaterThan', 0);
if ($securityWarnings->exists()) {
$alerts['SecurityAlerts'] = $securityWarnings->renderWith('SecurityAlertSummary');
}
} | php | {
"resource": ""
} |
q1325 | SearchController.show | train | public function show()
{
$keyword = request('q');
$articles = [];
$limit = abs(request('limit', config('site.limit', 10)));
$max_limit = config('site.max_limit', 100);
if ($limit > $max_limit) {
$limit = $max_limit;
}
if ($keyword) {
$articles = $this->engine->search($keyword, $limit);
$articles->appends('q', $keyword);
$articles->appends('limit', $limit);
}
return view('search.show', compact('articles', 'keyword'));
} | php | {
"resource": ""
} |
q1326 | WidgetsController.create | train | public function create(Widget $widget)
{
$widget->extension_id = old('extension_id', Extension::WIDGET_WYSIWYG);
$widget->template = old('template', 'widgets.wysiwyg.raw');
$widget->published = old('published', true);
return view('administrator.widgets.create', compact('widget'));
} | php | {
"resource": ""
} |
q1327 | WidgetsController.store | train | public function store(WidgetFormRequest $request)
{
$widget = new Widget;
$widget->fill($request->all());
$widget->published = $request->get('published', false);
$widget->authenticated = $request->get('authenticated', false);
$widget->show_title = $request->get('show_title', false);
$widget->save();
$widget->syncPermissions($request->get('permissions', []));
$widget->syncMenuAssignment($request->get('menu', []), $request->get('assignment', Widget::ALL_PAGES));
flash()->success(trans('cms::widget.store.success'));
return redirect()->route('administrator.widgets.index');
} | php | {
"resource": ""
} |
q1328 | WidgetsController.edit | train | public function edit(Widget $widget)
{
$widget->type = old('type', $widget->type);
$widget->template = old('template', $widget->template);
return view('administrator.widgets.edit', compact('widget'));
} | php | {
"resource": ""
} |
q1329 | WidgetsController.templates | train | public function templates($type)
{
$data = [];
$extension = $this->repository->findOrFail($type);
foreach ($extension->param('templates') as $template) {
$data[] = ['key' => $template['path'], 'value' => $template['description']];
}
return response()->json([
'template' => $data[0]['key'],
'selected' => $type,
'data' => $data,
], 200);
} | php | {
"resource": ""
} |
q1330 | WidgetsController.parameters | train | public function parameters($id, $widget)
{
$widget = Widget::withoutGlobalScope('menu_assignment')->findOrNew($widget);
$extension = $this->repository->findOrFail($id);
$formView = $extension->param('form');
if (view()->exists($formView)) {
return view($formView, compact('widget'));
}
return view('widgets.partials.none');
} | php | {
"resource": ""
} |
q1331 | CssToHTML.createStylesheetPaths | train | public function createStylesheetPaths(array $stylesheets)
{
$sheets = array();
foreach ($stylesheets as $key => $sheet) {
if (!$this->isExternalStylesheet($sheet)) {
// assetic version removal
$sheet = str_replace(strrchr($sheet, 'css?'), 'css', $sheet);
$sheet = $this->getBasePath() . $sheet;
}
$sheets[] = $sheet;
}
return $sheets;
} | php | {
"resource": ""
} |
q1332 | CssToHTML.getStylesheetContent | train | private function getStylesheetContent($path)
{
if ($this->isExternalStylesheet($path)) {
$cssData = $this->getRequestHandler()->getContent($path);
} else {
if (file_exists($path)) {
$cssData = file_get_contents($path);
} else {
return;
}
}
$cssData = $this->replaceLocalUrlTags($cssData);
return "<style type=\"text/css\">\n" . $cssData . '</style>';
} | php | {
"resource": ""
} |
q1333 | SignPresenter.actionForgottenPassword | train | public function actionForgottenPassword(): void
{
$session = $this->getSession('cms/forgottenPassword');
if ($session->count >= self::MAX_TRY) {
$this->flashNotifier->warning('cms.user.restorePasswordDisabledForHour');
$this->redirect(":{$this->module}:Sign:in");
}
} | php | {
"resource": ""
} |
q1334 | SignPresenter.signInFormSucceeded | train | public function signInFormSucceeded(Form $form, ArrayHash $values)
{
try {
$this->user->login($values->username, $values->password);
if ($values->remember) {
$this->user->setExpiration('+ ' . $this->sessionExpiration, false);
} else {
$this->user->setExpiration('+ ' . $this->loginExpiration, true);
}
$this->restoreRequest($this->backlink);
$this->redirect(":{$this->module}:Homepage:");
} catch (AuthenticationException $e) {
if ($e->getCode() == IAuthenticator::NOT_APPROVED) {
$form->addError('cms.user.accountDeactivated');
} else {
$form->addError('cms.user.incorrectUsernameOrPassword');
}
}
} | php | {
"resource": ""
} |
q1335 | SignPresenter.createComponentForgottenPasswordForm | train | protected function createComponentForgottenPasswordForm(): Form
{
$form = $this->formFactory->create();
$form->addProtection();
$form->addText('usernameOrEmail', 'cms.user.usernameOrEmail')
->setRequired();
$form->addSubmit('send', 'form.send');
$form->addLink('back', 'form.back', $this->link('in'));
$form->onSuccess[] = [$this, 'forgottenPasswordFormSucceeded'];
return $form;
} | php | {
"resource": ""
} |
q1336 | SignPresenter.forgottenPasswordFormSucceeded | train | public function forgottenPasswordFormSucceeded(Form $form, ArrayHash $values): void
{
$value = $values->usernameOrEmail;
$user = $this->orm->users->getByUsername($value);
if (!$user) {
$user = $this->orm->users->getByEmail($value);
if (!$user) {
$form->addError('cms.user.incorrectUsernameOrEmail');
$session = $this->getSession('cms/forgottenPassword');
if (isset($session->count)) {
$session->count++;
} else {
$session->setExpiration('1 hours');
$session->count = 1;
}
$this->actionForgottenPassword();
return;
}
}
$hash = $this->hasher->hash(Random::generate());
$session = $this->getSession('cms/restorePassword');
$session->setExpiration('1 hours');
$session->$hash = $user->email;
$this->mailer->sendRestorePassword($user->email, $hash);
$this->flashNotifier->info('cms.user.mailToRestorePasswordSent');
$this->redirect(":{$this->module}:Sign:in");
} | php | {
"resource": ""
} |
q1337 | SignPresenter.createComponentRestorePasswordForm | train | protected function createComponentRestorePasswordForm(): Form
{
$form = $this->formFactory->create();
$form->addProtection();
$form->addHidden('hash');
$form->addPassword('password', 'cms.user.newPassword')
->setRequired()
->addRule(Form::MIN_LENGTH, null, $this->minPasswordLength);
$form->addPassword('passwordVerify', 'cms.user.passwordVerify')
->setRequired()
->addRule(Form::EQUAL, null, $form['password']);
$form->addSubmit('restore', 'form.save');
$form->onSuccess[] = [$this, 'restorePasswordFormSucceeded'];
return $form;
} | php | {
"resource": ""
} |
q1338 | SignPresenter.restorePasswordFormSucceeded | train | public function restorePasswordFormSucceeded(Form $form, ArrayHash $values): void
{
$session = $this->getSession('cms/restorePassword');
$email = $session->{$values->hash};
$session->remove();
$user = $this->orm->users->getByEmail($email);
if ($user) {
$user->setPassword($values->password);
$this->orm->persistAndFlush($user);
$this->flashNotifier->success('cms.user.passwordChanged');
} else {
$this->flashNotifier->error('cms.permissions.accessDenied');
}
$this->redirect(":{$this->module}:Sign:in");
} | php | {
"resource": ""
} |
q1339 | SignPresenter.createComponentRegisterAdministratorForm | train | protected function createComponentRegisterAdministratorForm(): Form
{
$form = $this->formFactory->create();
$form->addProtection();
$form->addText('username', 'cms.user.username')
->setRequired();
$form->addText('firstName', 'cms.user.firstName');
$form->addText('surname', 'cms.user.surname');
$form->addText('email', 'cms.user.email')
->setRequired()
->addRule(Form::EMAIL);
$form->addPassword('password', 'cms.user.newPassword')
->setRequired()
->addRule(Form::MIN_LENGTH, null, $this->minPasswordLength);
$form->addPassword('passwordVerify', 'cms.user.passwordVerify')
->setRequired()
->addRule(Form::EQUAL, null, $form['password']);
$form->addSubmit('create', 'form.save');
$form->onSuccess[] = [$this, 'registerAdministratorFormSucceeded'];
return $form;
} | php | {
"resource": ""
} |
q1340 | SignPresenter.registerAdministratorFormSucceeded | train | public function registerAdministratorFormSucceeded(Form $form, ArrayHash $values): void
{
$password = $values->password;
$role = $this->orm->aclRoles->getByName(AclRolesMapper::SUPERADMIN);
$user = new User;
$user->firstName = $values->firstName;
$user->surname = $values->surname;
$user->email = $values->email;
$user->username = $values->username;
$user->setPassword($password);
$user->roles->add($role);
$this->orm->persistAndFlush($user);
$this->user->setExpiration('+ ' . $this->loginExpiration, true);
$this->user->login($values->username, $password);
$this->flashNotifier->success('cms.user.dataSaved');
$this->redirect(":{$this->module}:Homepage:");
} | php | {
"resource": ""
} |
q1341 | Message.create | train | public function create(MessageCreateEvent $event, $eventName, EventDispatcherInterface $dispatcher)
{
$message = new MessageModel();
$message
->setDispatcher($dispatcher)
->setName($event->getMessageName())
->setLocale($event->getLocale())
->setTitle($event->getTitle())
->setSecured($event->getSecured())
->save()
;
$event->setMessage($message);
} | php | {
"resource": ""
} |
q1342 | Message.modify | train | public function modify(MessageUpdateEvent $event, $eventName, EventDispatcherInterface $dispatcher)
{
if (null !== $message = MessageQuery::create()->findPk($event->getMessageId())) {
$message
->setDispatcher($dispatcher)
->setName($event->getMessageName())
->setSecured($event->getSecured())
->setLocale($event->getLocale())
->setTitle($event->getTitle())
->setSubject($event->getSubject())
->setHtmlMessage($event->getHtmlMessage())
->setTextMessage($event->getTextMessage())
->setHtmlLayoutFileName($event->getHtmlLayoutFileName())
->setHtmlTemplateFileName($event->getHtmlTemplateFileName())
->setTextLayoutFileName($event->getTextLayoutFileName())
->setTextTemplateFileName($event->getTextTemplateFileName())
->save();
$event->setMessage($message);
}
} | php | {
"resource": ""
} |
q1343 | Message.delete | train | public function delete(MessageDeleteEvent $event, $eventName, EventDispatcherInterface $dispatcher)
{
if (null !== ($message = MessageQuery::create()->findPk($event->getMessageId()))) {
$message
->setDispatcher($dispatcher)
->delete()
;
$event->setMessage($message);
}
} | php | {
"resource": ""
} |
q1344 | ConditionAbstract.getValidators | train | public function getValidators()
{
$this->validators = $this->generateInputs();
$translatedInputs = [];
foreach ($this->validators as $key => $validator) {
$translatedOperators = [];
foreach ($validator['availableOperators'] as $availableOperators) {
$translatedOperators[$availableOperators] = Operators::getI18n(
$this->translator,
$availableOperators
);
}
$validator['availableOperators'] = $translatedOperators;
$translatedInputs[$key] = $validator;
}
$validators = [
'inputs' => $translatedInputs,
'setOperators' => $this->operators,
'setValues' => $this->values
];
return $validators;
} | php | {
"resource": ""
} |
q1345 | ConditionAbstract.getSerializableCondition | train | public function getSerializableCondition()
{
$serializableCondition = new SerializableCondition();
$serializableCondition->conditionServiceId = $this->getServiceId();
$serializableCondition->operators = $this->operators;
$serializableCondition->values = $this->values;
return $serializableCondition;
} | php | {
"resource": ""
} |
q1346 | ConditionAbstract.isCurrencyValid | train | protected function isCurrencyValid($currencyValue)
{
$availableCurrencies = $this->facade->getAvailableCurrencies();
/** @var Currency $currency */
$currencyFound = false;
foreach ($availableCurrencies as $currency) {
if ($currencyValue == $currency->getCode()) {
$currencyFound = true;
}
}
if (!$currencyFound) {
throw new InvalidConditionValueException(
\get_class(),
'currency'
);
}
return true;
} | php | {
"resource": ""
} |
q1347 | ConditionAbstract.isPriceValid | train | protected function isPriceValid($priceValue)
{
$floatType = new FloatType();
if (!$floatType->isValid($priceValue) || $priceValue <= 0) {
throw new InvalidConditionValueException(
\get_class(),
'price'
);
}
return true;
} | php | {
"resource": ""
} |
q1348 | ConditionAbstract.drawBackOfficeInputOperators | train | protected function drawBackOfficeInputOperators($inputKey)
{
$html = '';
$inputs = $this->getValidators();
if (isset($inputs['inputs'][$inputKey])) {
$html = $this->facade->getParser()->render(
'coupon/condition-fragments/condition-selector.html',
[
'operators' => $inputs['inputs'][$inputKey]['availableOperators'],
'value' => isset($this->operators[$inputKey]) ? $this->operators[$inputKey] : '',
'inputKey' => $inputKey
]
);
}
return $html;
} | php | {
"resource": ""
} |
q1349 | ConditionAbstract.drawBackOfficeBaseInputsText | train | protected function drawBackOfficeBaseInputsText($label, $inputKey)
{
$operatorSelectHtml = $this->drawBackOfficeInputOperators($inputKey);
$currentValue = '';
if (isset($this->values) && isset($this->values[$inputKey])) {
$currentValue = $this->values[$inputKey];
}
return $this->facade->getParser()->render(
'coupon/conditions-fragments/base-input-text.html',
[
'label' => $label,
'inputKey' => $inputKey,
'currentValue' => $currentValue,
'operatorSelectHtml' => $operatorSelectHtml
]
);
} | php | {
"resource": ""
} |
q1350 | ConditionAbstract.drawBackOfficeInputQuantityValues | train | protected function drawBackOfficeInputQuantityValues($inputKey, $max = 10, $min = 0)
{
return $this->facade->getParser()->render(
'coupon/condition-fragments/quantity-selector.html',
[
'min' => $min,
'max' => $max,
'value' => isset($this->values[$inputKey]) ? $this->values[$inputKey] : '',
'inputKey' => $inputKey
]
);
} | php | {
"resource": ""
} |
q1351 | ConditionAbstract.drawBackOfficeCurrencyInput | train | protected function drawBackOfficeCurrencyInput($inputKey)
{
$currencies = CurrencyQuery::create()->find();
$cleanedCurrencies = [];
/** @var Currency $currency */
foreach ($currencies as $currency) {
$cleanedCurrencies[$currency->getCode()] = $currency->getSymbol();
}
return $this->facade->getParser()->render(
'coupon/condition-fragments/currency-selector.html',
[
'currencies' => $cleanedCurrencies,
'value' => isset($this->values[$inputKey]) ? $this->values[$inputKey] : '',
'inputKey' => $inputKey
]
);
} | php | {
"resource": ""
} |
q1352 | Notice.setClass | train | private function setClass( $name, $args ) {
// Build the class string dynamically.
$class = __NAMESPACE__ . '\\Notice\\' . ucfirst( $name );
// Create a new instance or add our filters.
return $this->class = class_exists( $class ) ? new $class( $args ) : Filter::add( $this );
} | php | {
"resource": ""
} |
q1353 | Notice.show | train | public static function show( $message, $id, $class = "notice notice-warning" ) {
$nonce = wp_nonce_field( 'boldgrid_set_key', 'set_key_auth', true, false );
if( self::isDismissed( $id ) ) {
return;
}
printf( '<div class="%1$s boldgrid-notice is-dismissible" data-notice-id="%2$s">%3$s%4$s</div>',
$class,
$id,
$message,
$nonce
);
/*
* Enqueue js required to allow for notices to be dismissed permanently.
*
* When notices (such as the "keyPrompt" notice) are shown by creating a new instance of
* this class, the js is enqueued by the Filter::add call in the constructor. We do however
* allow notices to be shown via this static method, and so we need to enqueue the js now.
*/
self::enqueue();
} | php | {
"resource": ""
} |
q1354 | Notice.add | train | public function add( $name = null ) {
$name = $name ? $name : $this->getName();
$path = __DIR__;
$name = ucfirst( $name );
include "{$path}/Views/{$name}.php";
} | php | {
"resource": ""
} |
q1355 | Notice.dismiss | train | public function dismiss() {
// Validate nonce.
if ( isset( $_POST['set_key_auth'] ) && check_ajax_referer( 'boldgrid_set_key', 'set_key_auth', false ) ) {
$id = sanitize_key( $_POST['notice'] );
// Mark the notice as dismissed, if not already done so.
$dismissal = array(
'id' => $id,
'timestamp' => time(),
);
if ( ! Notice::isDismissed( $id ) ) {
add_user_meta( get_current_user_id(), 'boldgrid_dismissed_admin_notices', $dismissal );
}
}
} | php | {
"resource": ""
} |
q1356 | Notice.undismiss | train | public function undismiss() {
// Validate nonce.
if ( isset( $_POST['set_key_auth'] ) && ! empty( $_POST['notice'] ) && check_ajax_referer( 'boldgrid_set_key', 'set_key_auth', false ) ) {
$id = sanitize_key( $_POST['notice'] );
// Get all of the notices this user has dismissed.
$dismissals = get_user_meta( get_current_user_id(), 'boldgrid_dismissed_admin_notices' );
// Loop through all of the dismissed notices. If we find the dismissal, then remove it.
foreach ( $dismissals as $dismissal ) {
if ( $id === $dismissal['id'] ) {
delete_user_meta( get_current_user_id(), 'boldgrid_dismissed_admin_notices', $dismissal );
break;
}
}
}
} | php | {
"resource": ""
} |
q1357 | Notice.isDismissed | train | public static function isDismissed( $id ) {
$dismissed = false;
$id = sanitize_key( $id );
// Get all of the notices this user has dismissed.
$dismissals = get_user_meta( get_current_user_id(), 'boldgrid_dismissed_admin_notices' );
// Loop through all of the dismissed notices. If we find our $id, then mark bool and break.
foreach ( $dismissals as $dismissal ) {
if ( $id === $dismissal['id'] ) {
$dismissed = true;
break;
}
}
return $dismissed;
} | php | {
"resource": ""
} |
q1358 | CheckPermission.exec | train | public function exec()
{
if (version_compare(phpversion(), '5.5', '<')) {
$this->validationMessages['php_version']['text'] = $this->getI18nPhpVersionText('5.5', phpversion(), false);
$this->validationMessages['php_version']['status'] = false;
$this->validationMessages['php_version']['hint'] = $this->getI18nPhpVersionHint();
}
foreach ($this->directoriesToBeWritable as $directory) {
$fullDirectory = THELIA_ROOT . $directory;
$this->validationMessages[$directory]['text'] = $this->getI18nDirectoryText($fullDirectory, true);
if (is_writable($fullDirectory) === false) {
if (!$this->makeDirectoryWritable($fullDirectory)) {
$this->isValid = false;
$this->validationMessages[$directory]['status'] = false;
$this->validationMessages[$directory]['text'] = $this->getI18nDirectoryText($fullDirectory, false);
}
}
}
foreach ($this->minServerConfigurationNecessary as $key => $value) {
$this->validationMessages[$key]['text'] = $this->getI18nConfigText($key, $this->formatBytes($value), ini_get($key), true);
if (!$this->verifyServerMemoryValues($key, $value)) {
$this->isValid = false;
$this->validationMessages[$key]['status'] = false;
$this->validationMessages[$key]['text'] = $this->getI18nConfigText($key, $this->formatBytes($value), ini_get($key), false);
;
}
}
foreach ($this->extensions as $extension) {
$this->validationMessages[$extension]['text'] = $this->getI18nExtensionText($extension, true);
if (false === extension_loaded($extension)) {
$this->isValid = false;
$this->validationMessages[$extension]['status'] = false;
$this->validationMessages[$extension]['text'] = $this->getI18nExtensionText($extension, false);
}
}
return $this->isValid;
} | php | {
"resource": ""
} |
q1359 | CheckPermission.getI18nDirectoryText | train | protected function getI18nDirectoryText($directory, $isValid)
{
if ($this->translator !== null) {
if ($isValid) {
$sentence = 'The directory %directory% is writable';
} else {
$sentence = 'The directory %directory% is not writable';
}
$translatedText = $this->translator->trans(
$sentence,
array(
'%directory%' => $directory
)
);
} else {
$translatedText = sprintf('The directory %s should be writable', $directory);
}
return $translatedText;
} | php | {
"resource": ""
} |
q1360 | CheckPermission.getI18nConfigText | train | protected function getI18nConfigText($key, $expectedValue, $currentValue, $isValid)
{
if ($isValid) {
$sentence = 'The PHP "%key%" configuration value (currently %currentValue%) is correct (%expectedValue% required).';
} else {
$sentence = 'The PHP "%key%" configuration value (currently %currentValue%) is below minimal requirements to run Thelia2 (%expectedValue% required).';
}
$translatedText = $this->translator->trans(
$sentence,
array(
'%key%' => $key,
'%expectedValue%' => $expectedValue,
'%currentValue%' => $currentValue,
),
'install-wizard'
);
return $translatedText;
} | php | {
"resource": ""
} |
q1361 | CheckPermission.getI18nPhpVersionText | train | protected function getI18nPhpVersionText($expectedValue, $currentValue, $isValid)
{
if ($this->translator !== null) {
if ($isValid) {
$sentence = 'PHP version %currentValue% matches the minimum required (PHP %expectedValue%).';
} else {
$sentence = 'The installer detected PHP version %currentValue%, but Thelia 2 requires PHP %expectedValue% or newer.';
}
$translatedText = $this->translator->trans(
$sentence,
array(
'%expectedValue%' => $expectedValue,
'%currentValue%' => $currentValue,
)
);
} else {
$translatedText = sprintf('Thelia requires PHP %s or newer (%s currently).', $expectedValue, $currentValue);
}
return $translatedText;
} | php | {
"resource": ""
} |
q1362 | CheckPermission.verifyServerMemoryValues | train | protected function verifyServerMemoryValues($key, $necessaryValueInBytes)
{
$serverValueInBytes = $this->returnBytes(ini_get($key));
if ($serverValueInBytes == -1) {
return true;
}
return ($serverValueInBytes >= $necessaryValueInBytes);
} | php | {
"resource": ""
} |
q1363 | CheckPermission.returnBytes | train | protected function returnBytes($val)
{
$val = trim($val);
$last = strtolower($val[strlen($val)-1]);
// Do not add breaks in the switch below
switch ($last) {
// The 'G' modifier is available since PHP 5.1.0
case 'g':
$val = (int)$val*1024;
// no break
case 'm':
$val = (int)$val*1024;
// no break
case 'k':
$val = (int)$val*1024;
}
return $val;
} | php | {
"resource": ""
} |
q1364 | MelisCmsRightsService.isActionButtonActive | train | public function isActionButtonActive($actionwanted)
{
$active = 0;
$pathArrayConfig = '';
switch ($actionwanted)
{
case 'save' : $pathArrayConfig = 'meliscms_page_action_save';
break;
case 'delete' : $pathArrayConfig = 'meliscms_page_action_delete';
break;
case 'publish' : $pathArrayConfig = 'meliscms_page_action_publishunpublish';
break;
case 'unpublish' : $pathArrayConfig = 'meliscms_page_action_publishunpublish';
break;
}
$melisAppConfig = $this->getServiceLocator()->get('MelisCoreConfig');
$melisKeys = $melisAppConfig->getMelisKeys();
$melisCoreAuth = $this->getServiceLocator()->get('MelisCoreAuth');
$xmlRights = $melisCoreAuth->getAuthRights();
$melisCoreRights = $this->getServiceLocator()->get('MelisCoreRights');
if (!empty($melisKeys[$pathArrayConfig]))
{
$isAccessible = $melisCoreRights->isAccessible($xmlRights, MelisCoreRightsService::MELISCORE_PREFIX_INTERFACE, $melisKeys[$pathArrayConfig]);
if ($isAccessible)
$active = 1;
}
return $active;
} | php | {
"resource": ""
} |
q1365 | RedisThrottler.trackMeter | train | protected function trackMeter($meterId, $buckets, $rates)
{
// create a key for this bucket's start time
$trackKey = sprintf('track:%s', $buckets[0]);
// track the meter key to this bucket with the number of times it was called
$this->redis->hset($trackKey, $meterId, $rates[0]);
// ensure this meter expires
$expireAt = $buckets[0] + ($this->config['bucket_size'] * $this->config['num_buckets']);
$this->redis->expireat($trackKey, $expireAt);
} | php | {
"resource": ""
} |
q1366 | Tax.afterTax | train | public static function afterTax($amount, Taxable $taxable)
{
return static::beforeTax(
$taxable->getAmountWithoutTax(static::asMoney($amount)), $taxable
);
} | php | {
"resource": ""
} |
q1367 | Tax.getAmountWithTax | train | public function getAmountWithTax(): string
{
if (! $this->hasTax()) {
return $this->getMoney()->getAmount();
}
return $this->getTax()->getAmountWithTax($this->getMoney());
} | php | {
"resource": ""
} |
q1368 | Tax.allocateWithTax | train | public function allocateWithTax(array $ratios): array
{
$method = $this->hasTax() ? 'afterTax' : 'withoutTax';
$results = [];
$allocates = static::asMoney($this->getAmountWithTax())->allocate($ratios);
foreach ($allocates as $allocate) {
$results[] = static::{$method}($allocate->getAmount(), $this->getTax());
}
return $results;
} | php | {
"resource": ""
} |
q1369 | Tax.allocateWithTaxTo | train | public function allocateWithTaxTo(int $n): array
{
$method = $this->hasTax() ? 'afterTax' : 'withoutTax';
$results = [];
$allocates = static::asMoney($this->getAmountWithTax())->allocateTo($n);
foreach ($allocates as $allocate) {
$results[] = static::{$method}($allocate->getAmount(), $this->getTax());
}
return $results;
} | php | {
"resource": ""
} |
q1370 | Lang.getDefaultLanguage | train | public static function getDefaultLanguage()
{
if (null === self::$defaultLanguage) {
self::$defaultLanguage = LangQuery::create()->findOneByByDefault(1);
if (null === self::$defaultLanguage) {
throw new \RuntimeException("No default language is defined. Please define one.");
}
}
return self::$defaultLanguage;
} | php | {
"resource": ""
} |
q1371 | MetaModelTags.convertValuesToIds | train | private function convertValuesToIds($varValue): array
{
$aliasColumn = $this->getAliasColumn();
$alias = [];
foreach ($varValue as $valueId => $value) {
if (array_key_exists($aliasColumn, $value)) {
$alias[$valueId] = $value[$aliasColumn];
continue;
}
if (array_key_exists(self::TAGS_RAW, $value) && array_key_exists($aliasColumn, $value[self::TAGS_RAW])) {
$alias[$valueId] = $value[self::TAGS_RAW][$aliasColumn];
}
}
return $alias;
} | php | {
"resource": ""
} |
q1372 | MetaModelTags.calculateFilterOptionsCount | train | protected function calculateFilterOptionsCount($items, &$amountArray, $idList)
{
$builder = $this
->getConnection()
->createQueryBuilder()
->select('value_id')
->addSelect('COUNT(item_id) AS amount')
->from('tl_metamodel_tag_relation')
->where('att_id=:attId')
->setParameter('attId', $this->get('id'))
->groupBy('value_id');
if (0 < $items->getCount()) {
$ids = [];
foreach ($items as $item) {
$ids[] = $item->get('id');
}
$builder
->andWhere('value_id IN (:valueIds)')
->setParameter('valueIds', $ids, Connection::PARAM_STR_ARRAY);
if ($idList && \is_array($idList)) {
$builder
->andWhere('item_id IN (:itemIds)')
->setParameter('itemIds', $idList, Connection::PARAM_STR_ARRAY);
}
}
$counts = $builder->execute();
foreach ($counts->fetchAll(\PDO::FETCH_ASSOC) as $count) {
$amountArray[$count['value_id']] = $count['amount'];
}
} | php | {
"resource": ""
} |
q1373 | PositionManagementTrait.getNextPosition | train | public function getNextPosition()
{
$query = $this->createQuery()
->orderByPosition(Criteria::DESC)
->limit(1);
$this->addCriteriaToPositionQuery($query);
$last = $query->findOne();
return $last != null ? $last->getPosition() + 1 : 1;
} | php | {
"resource": ""
} |
q1374 | PositionManagementTrait.movePositionUpOrDown | train | protected function movePositionUpOrDown($up = true)
{
// The current position of the object
$myPosition = $this->getPosition();
// Find object to exchange position with
$search = $this->createQuery();
$this->addCriteriaToPositionQuery($search);
// Up or down ?
if ($up === true) {
// Find the object immediately before me
$search->filterByPosition(array('max' => $myPosition-1))->orderByPosition(Criteria::DESC);
} else {
// Find the object immediately after me
$search->filterByPosition(array('min' => $myPosition+1))->orderByPosition(Criteria::ASC);
}
$result = $search->findOne();
// If we found the proper object, exchange their positions
if ($result) {
$cnx = Propel::getWriteConnection($this->getDatabaseName());
$cnx->beginTransaction();
try {
$this
->setPosition($result->getPosition())
->save($cnx)
;
// For BC
if (method_exists($result, 'setDispatcher') && method_exists($this, 'getDispatcher')) {
$result->setDispatcher($this->getDispatcher());
}
$result->setPosition($myPosition)->save($cnx);
$cnx->commit();
} catch (\Exception $e) {
$cnx->rollback();
}
}
} | php | {
"resource": ""
} |
q1375 | PositionManagementTrait.changeAbsolutePosition | train | public function changeAbsolutePosition($newPosition)
{
// The current position
$current_position = $this->getPosition();
if ($newPosition != null && $newPosition > 0 && $newPosition != $current_position) {
// Find categories to offset
$search = $this->createQuery();
$this->addCriteriaToPositionQuery($search);
if ($newPosition > $current_position) {
// The new position is after the current position -> we will offset + 1 all categories located between us and the new position
$search->filterByPosition(array('min' => 1+$current_position, 'max' => $newPosition));
$delta = -1;
} else {
// The new position is brefore the current position -> we will offset - 1 all categories located between us and the new position
$search->filterByPosition(array('min' => $newPosition, 'max' => $current_position - 1));
$delta = 1;
}
$results = $search->find();
$cnx = Propel::getWriteConnection($this->getDatabaseName());
$cnx->beginTransaction();
try {
foreach ($results as $result) {
$objNewPosition = $result->getPosition() + $delta;
// For BC
if (method_exists($result, 'setDispatcher') && method_exists($this, 'getDispatcher')) {
$result->setDispatcher($this->getDispatcher());
}
$result->setPosition($objNewPosition)->save($cnx);
}
$this
->setPosition($newPosition)
->save($cnx)
;
$cnx->commit();
} catch (\Exception $e) {
$cnx->rollback();
}
}
} | php | {
"resource": ""
} |
q1376 | SchemaLocator.findForActiveModules | train | public function findForActiveModules()
{
$fs = new Filesystem();
$codes = $this->queryActiveModuleCodes();
foreach ($codes as $key => $code) {
// test if the module exists on the file system
if (!$fs->exists(THELIA_MODULE_DIR . $code)) {
unset($codes[$key]);
}
}
// reset keys
$codes = array_values($codes);
return $this->findForModules($codes);
} | php | {
"resource": ""
} |
q1377 | SchemaLocator.addModulesDependencies | train | protected function addModulesDependencies(array $modules = [])
{
if (empty($modules)) {
return [];
}
// Thelia is always a dependency
if (!\in_array('Thelia', $modules)) {
$modules[] = 'Thelia';
}
foreach ($modules as $module) {
// Thelia is not a real module, do not try to get its dependencies
if ($module === 'Thelia') {
continue;
}
$moduleValidator = new ModuleValidator("{$this->theliaModuleDir}/{$module}");
$dependencies = $moduleValidator->getCurrentModuleDependencies(true);
foreach ($dependencies as $dependency) {
if (!\in_array($dependency['code'], $modules)) {
$modules[] = $dependency['code'];
}
}
}
return $modules;
} | php | {
"resource": ""
} |
q1378 | SchemaLocator.addExternalSchemaDocuments | train | protected function addExternalSchemaDocuments(array $schemaDocuments)
{
$fs = new Filesystem();
$externalSchemaDocuments = [];
foreach ($schemaDocuments as $schemaDocument) {
/** @var \DOMElement $externalSchemaElement */
foreach ($schemaDocument->getElementsByTagName('external-schema') as $externalSchemaElement) {
if (!$externalSchemaElement->hasAttribute('filename')) {
continue;
}
$externalSchemaPath = $externalSchemaElement->getAttribute('filename');
if (!$fs->exists($externalSchemaPath)) {
continue;
}
$externalSchemaDocument = new \DOMDocument();
if (!$externalSchemaDocument->load($externalSchemaPath)) {
continue;
}
$externalSchemaDocuments[] = $externalSchemaDocument;
}
}
return $this->mergeDOMDocumentsArrays([$schemaDocuments, $externalSchemaDocuments]);
} | php | {
"resource": ""
} |
q1379 | NotifyMeManager.reconnect | train | public function reconnect($name = null)
{
$name = $name ?: $this->default;
$this->disconnect($name);
return $this->connection($name);
} | php | {
"resource": ""
} |
q1380 | BaseAdminController.adminLogAppend | train | public function adminLogAppend($resource, $action, $message, $resourceId = null)
{
AdminLog::append(
$resource,
$action,
$message,
$this->getRequest(),
$this->getSecurityContext()->getAdminUser(),
true,
$resourceId
);
} | php | {
"resource": ""
} |
q1381 | BaseAdminController.processTemplateAction | train | public function processTemplateAction($template)
{
try {
if (! empty($template)) {
// If we have a view in the URL, render this view
return $this->render($template);
} elseif (null != $view = $this->getRequest()->get('view')) {
return $this->render($view);
}
} catch (\Exception $ex) {
return $this->errorPage($ex->getMessage());
}
return $this->pageNotFound();
} | php | {
"resource": ""
} |
q1382 | BaseAdminController.errorPage | train | protected function errorPage($message, $status = 500)
{
if ($message instanceof \Exception) {
$strMessage = $this->getTranslator()->trans(
"Sorry, an error occured: %msg",
[ '%msg' => $message->getMessage() ]
);
Tlog::getInstance()->addError($strMessage.": ".$message->getTraceAsString());
$message = $strMessage;
} else {
Tlog::getInstance()->addError($message);
}
return $this->render(
'general_error',
array(
"error_message" => $message
),
$status
);
} | php | {
"resource": ""
} |
q1383 | BaseAdminController.checkAuth | train | protected function checkAuth($resources, $modules, $accesses)
{
$resources = \is_array($resources) ? $resources : array($resources);
$modules = \is_array($modules) ? $modules : array($modules);
$accesses = \is_array($accesses) ? $accesses : array($accesses);
if ($this->getSecurityContext()->isGranted(array("ADMIN"), $resources, $modules, $accesses)) {
// Okay !
return null;
}
// Log the problem
$this->adminLogAppend(implode(",", $resources), implode(",", $accesses), "User is not granted for resources %s with accesses %s", implode(", ", $resources), implode(", ", $accesses));
return $this->errorPage($this->getTranslator()->trans("Sorry, you're not allowed to perform this action"), 403);
} | php | {
"resource": ""
} |
q1384 | BaseAdminController.setupFormErrorContext | train | protected function setupFormErrorContext($action, $error_message, BaseForm $form = null, \Exception $exception = null)
{
if ($error_message !== false) {
// Log the error message
Tlog::getInstance()->error(
$this->getTranslator()->trans(
"Error during %action process : %error. Exception was %exc",
array(
'%action' => $action,
'%error' => $error_message,
'%exc' => $exception != null ? $exception->getMessage() : 'no exception'
)
)
);
if ($form != null) {
// Mark the form as errored
$form->setErrorMessage($error_message);
// Pass it to the parser context
$this->getParserContext()->addForm($form);
}
// Pass the error message to the parser.
$this->getParserContext()->setGeneralError($error_message);
}
} | php | {
"resource": ""
} |
q1385 | BaseAdminController.getCurrentEditionCurrency | train | protected function getCurrentEditionCurrency()
{
// Return the new language if a change is required.
if (null !== $edit_currency_id = $this->getRequest()->get('edit_currency_id', null)) {
if (null !== $edit_currency = CurrencyQuery::create()->findOneById($edit_currency_id)) {
return $edit_currency;
}
}
// Otherwise return the lang stored in session.
return $this->getSession()->getAdminEditionCurrency();
} | php | {
"resource": ""
} |
q1386 | BaseAdminController.getCurrentEditionLang | train | protected function getCurrentEditionLang()
{
// Return the new language if a change is required.
if (null !== $edit_language_id = $this->getRequest()->get('edit_language_id', null)) {
if (null !== $edit_language = LangQuery::create()->findOneById($edit_language_id)) {
return $edit_language;
}
}
// Otherwise return the lang stored in session.
return $this->getSession()->getAdminEditionLang();
} | php | {
"resource": ""
} |
q1387 | BaseAdminController.getUrlLanguage | train | protected function getUrlLanguage($locale = null)
{
// Check if the functionality is activated
if (!ConfigQuery::isMultiDomainActivated()) {
return null;
}
// If we don't have a locale value, use the locale value in the session
if (!$locale) {
$locale = $this->getCurrentEditionLocale();
}
return LangQuery::create()->findOneByLocale($locale)->getUrl();
} | php | {
"resource": ""
} |
q1388 | BaseAdminController.getListOrderFromSession | train | protected function getListOrderFromSession($objectName, $requestParameterName, $defaultListOrder, $updateSession = true)
{
$orderSessionIdentifier = sprintf("admin.%s.currentListOrder", $objectName);
// Find the current order
$order = $this->getRequest()->get(
$requestParameterName,
$this->getSession()->get($orderSessionIdentifier, $defaultListOrder)
);
if ($updateSession) {
$this->getSession()->set($orderSessionIdentifier, $order);
}
return $order;
} | php | {
"resource": ""
} |
q1389 | ParameterTrait.appendParameter | train | public function appendParameter($parameter) {
if (is_callable($parameter)) {
$parameter = $parameter($this);
}
if (!($parameter instanceof ParameterNode)) {
throw new \InvalidArgumentException();
}
$this->parameters->appendItem($parameter);
return $this;
} | php | {
"resource": ""
} |
q1390 | ParameterTrait.insertParameter | train | public function insertParameter(ParameterNode $parameter, $index) {
$this->parameters->insertItem($parameter, $index);
return $this;
} | php | {
"resource": ""
} |
q1391 | ParameterTrait.getParameter | train | public function getParameter($key) {
if (is_string($key)) {
return $this->getParameterByName($key);
}
elseif (is_integer($key)) {
return $this->getParameterAtIndex($key);
}
else {
throw new \InvalidArgumentException("Illegal parameter index {$key}.");
}
} | php | {
"resource": ""
} |
q1392 | ParameterTrait.getParameterByName | train | public function getParameterByName($name) {
$name = ltrim($name, '$');
/** @var ParameterNode $parameter */
foreach ($this->getParameters()->reverse() as $parameter) {
if ($parameter->getName() === $name) {
return $parameter;
}
}
throw new \UnexpectedValueException("Parameter {$name} does not exist.");
} | php | {
"resource": ""
} |
q1393 | URL.getBaseUrl | train | public function getBaseUrl($scheme_only = false)
{
if (null === $this->baseUrlScheme) {
$scheme = "http";
$port = 80;
if ($host = $this->requestContext->getHost()) {
$scheme = $this->requestContext->getScheme();
$port = '';
if ('http' === $scheme && 80 != $this->requestContext->getHttpPort()) {
$port = ':'.$this->requestContext->getHttpPort();
} elseif ('https' === $scheme && 443 != $this->requestContext->getHttpsPort()) {
$port = ':'.$this->requestContext->getHttpsPort();
}
}
$this->baseUrlScheme = "$scheme://$host"."$port";
}
return $scheme_only ? $this->baseUrlScheme : $this->baseUrlScheme . $this->requestContext->getBaseUrl();
} | php | {
"resource": ""
} |
q1394 | URL.adminViewUrl | train | public function adminViewUrl($viewName, array $parameters = array())
{
$path = sprintf("%s/admin/%s", $this->getIndexPage(), $viewName);
return $this->absoluteUrl($path, $parameters);
} | php | {
"resource": ""
} |
q1395 | URL.viewUrl | train | public function viewUrl($viewName, array $parameters = array())
{
$path = sprintf("?view=%s", $viewName);
return $this->absoluteUrl($path, $parameters);
} | php | {
"resource": ""
} |
q1396 | URL.retrieve | train | public function retrieve($view, $viewId, $viewLocale)
{
if (ConfigQuery::isRewritingEnable()) {
$this->retriever->loadViewUrl($view, $viewLocale, $viewId);
} else {
$allParametersWithoutView = array();
$allParametersWithoutView['lang'] = $viewLocale;
if (null !== $viewId) {
$allParametersWithoutView[$view . '_id'] = $viewId;
}
$this->retriever->rewrittenUrl = null;
$this->retriever->url = URL::getInstance()->viewUrl($view, $allParametersWithoutView);
}
return $this->retriever;
} | php | {
"resource": ""
} |
q1397 | URL.retrieveCurrent | train | public function retrieveCurrent(Request $request)
{
if (ConfigQuery::isRewritingEnable()) {
$view = $request->attributes->get('_view', null);
$viewLocale = $this->getViewLocale($request);
$viewId = $view === null ? null : $request->query->get($view . '_id', null);
$allOtherParameters = $request->query->all();
if ($view !== null) {
unset($allOtherParameters['view']);
if ($viewId !== null) {
unset($allOtherParameters[$view . '_id']);
}
}
if ($viewLocale !== null) {
unset($allOtherParameters['lang']);
unset($allOtherParameters['locale']);
}
$this->retriever->loadSpecificUrl($view, $viewLocale, $viewId, $allOtherParameters);
} else {
$allParametersWithoutView = $request->query->all();
$view = $request->attributes->get('_view');
if (isset($allOtherParameters['view'])) {
unset($allOtherParameters['view']);
}
$this->retriever->rewrittenUrl = null;
$this->retriever->url = URL::getInstance()->viewUrl($view, $allParametersWithoutView);
}
return $this->retriever;
} | php | {
"resource": ""
} |
q1398 | URL.getViewLocale | train | private function getViewLocale(Request $request)
{
$viewLocale = $request->query->get('lang', null);
if (null === $viewLocale) {
// fallback for old parameter
$viewLocale = $request->query->get('locale', null);
}
return $viewLocale;
} | php | {
"resource": ""
} |
q1399 | OrderPostage.loadFromPostage | train | public static function loadFromPostage($postage)
{
if ($postage instanceof OrderPostage) {
$orderPostage = $postage;
} else {
$orderPostage = new OrderPostage($postage);
}
return $orderPostage;
} | php | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.