_id stringlengths 2 7 | title stringlengths 3 151 | partition stringclasses 3
values | text stringlengths 33 8k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q17200 | Helpers.mapAuthorityByClass | train | public static function mapAuthorityByClass(array $authorities)
{
$map = [];
foreach ($authorities as $authority) {
if ($authority instanceof Model) {
$map[get_class($authority)][] = $authority->getKey();
} else | php | {
"resource": ""
} |
q17201 | Helpers.partition | train | public static function partition($items, callable $callback)
{
$partitions = [new Collection, new Collection];
foreach ($items as $key => $item) {
| php | {
"resource": ""
} |
q17202 | Scope.applyToModel | train | public function applyToModel(Model $model)
{
if (! $this->onlyScopeRelations && | php | {
"resource": ""
} |
q17203 | Scope.applyToModelQuery | train | public function applyToModelQuery($query, $table = null)
{
if (is_null($this->scope) || $this->onlyScopeRelations) {
return $query;
}
if (is_null($table)) {
| php | {
"resource": ""
} |
q17204 | Scope.applyToRelationQuery | train | public function applyToRelationQuery($query, $table)
{
if (is_null($this->scope)) {
return $query;
| php | {
"resource": ""
} |
q17205 | Scope.applyToRelation | train | public function applyToRelation(BelongsToMany $relation)
{
$this->applyToRelationQuery(
$relation->getQuery(),
| php | {
"resource": ""
} |
q17206 | Scope.applyToQuery | train | protected function applyToQuery($query, $table)
{
return $query->where(function ($query) use | php | {
"resource": ""
} |
q17207 | Scope.getAttachAttributes | train | public function getAttachAttributes($authority = null)
{
if (is_null($this->scope)) {
return [];
}
| php | {
"resource": ""
} |
q17208 | Scope.onceTo | train | public function onceTo($scope, callable $callback)
{
$mainScope = $this->scope;
$this->scope = $scope;
| php | {
"resource": ""
} |
q17209 | BouncerServiceProvider.registerBouncer | train | protected function registerBouncer()
{
$this->app->singleton(Bouncer::class, function () {
return Bouncer::make()
->withClipboard(new CachedClipboard(new | php | {
"resource": ""
} |
q17210 | BouncerServiceProvider.getTablePrefix | train | protected function getTablePrefix()
{
$config = $this->app->config['database'];
$connection = array_get($config, 'default');
| php | {
"resource": ""
} |
q17211 | Abilities.forAuthority | train | public static function forAuthority(Model $authority, $allowed = true)
{
return Models::ability()->where(function ($query) use ($authority, $allowed) {
$query->whereExists(static::getRoleConstraint($authority, $allowed));
| php | {
"resource": ""
} |
q17212 | Abilities.getRoleConstraint | train | protected static function getRoleConstraint(Model $authority, $allowed)
{
return function ($query) use ($authority, $allowed) {
$permissions = Models::table('permissions');
$abilities = Models::table('abilities');
$roles = Models::table('roles');
$pref... | php | {
"resource": ""
} |
q17213 | Abilities.addRoleInheritCondition | train | protected static function addRoleInheritCondition(Builder $query, Model $authority, $roles)
{
$query->orWhere('level', '<', function ($query) use ($authority, $roles) {
$query->selectRaw('max(level)')
->from($roles)
| php | {
"resource": ""
} |
q17214 | Abilities.getAuthorityRoleConstraint | train | protected static function getAuthorityRoleConstraint(Model $authority)
{
return function ($query) use ($authority) {
$pivot = Models::table('assigned_roles');
$roles = Models::table('roles');
$table = $authority->getTable();
$prefix = Models::prefix();
... | php | {
"resource": ""
} |
q17215 | Abilities.getAuthorityConstraint | train | protected static function getAuthorityConstraint(Model $authority, $allowed)
{
return function ($query) use ($authority, $allowed) {
$permissions = Models::table('permissions');
$abilities = Models::table('abilities');
$table = $authority->getTable();
... | php | {
"resource": ""
} |
q17216 | Abilities.getEveryoneConstraint | train | protected static function getEveryoneConstraint($allowed)
{
return function ($query) use ($allowed) {
$permissions = Models::table('permissions');
$abilities = Models::table('abilities');
$prefix = Models::prefix();
$query->from($permissions)
... | php | {
"resource": ""
} |
q17217 | DisassociatesAbilities.to | train | public function to($abilities, $entity = null, array $attributes = [])
{
if (call_user_func_array([$this, 'shouldConductLazy'], func_get_args())) {
| php | {
"resource": ""
} |
q17218 | DisassociatesAbilities.disassociateAbilities | train | protected function disassociateAbilities($authority, array $ids)
{
if (is_null($authority)) {
$this->disassociateEveryone($ids);
| php | {
"resource": ""
} |
q17219 | DisassociatesAbilities.disassociateAuthority | train | protected function disassociateAuthority(Model $authority, array $ids)
{
| php | {
"resource": ""
} |
q17220 | DisassociatesAbilities.getAbilitiesPivotQuery | train | protected function getAbilitiesPivotQuery(Model $model, $ids)
{
$relation = $model->abilities();
list($foreignKeyName, $relatedKeyName) = $this->getRelationKeyNames($relation);
$query = $relation
->newPivotStatement()
->where($foreignKeyName, $model->getKey())
... | php | {
"resource": ""
} |
q17221 | DisassociatesAbilities.getRelationKeyNames | train | protected function getRelationKeyNames(MorphToMany $relation)
{
// We need to get the keys of both tables from the relation class.
// The method names have changed in Laravel 5.4 & again in 5.5,
// so we will first check which methods are available to us.
if (method_exists($relation,... | php | {
"resource": ""
} |
q17222 | DisassociatesAbilities.disassociateEveryone | train | protected function disassociateEveryone(array $ids)
{
$query = Models::query('permissions')
->whereNull('entity_id')
| php | {
"resource": ""
} |
q17223 | DisassociatesAbilities.getAuthority | train | protected function getAuthority()
{
if (is_null($this->authority)) {
return null;
}
if ($this->authority instanceof Model) {
| php | {
"resource": ""
} |
q17224 | Title.humanize | train | protected function humanize($value)
{
// Older versions of Laravel's inflector strip out spaces
// in the original string, so we'll first swap out all
// spaces with underscores, then convert them back.
$value = str_replace(' ', '_', $value);
// First we'll convert the strin... | php | {
"resource": ""
} |
q17225 | SyncsRolesAndAbilities.roles | train | public function roles($roles)
{
$this->sync(
Models::role()->getRoleKeys($roles),
| php | {
"resource": ""
} |
q17226 | SyncsRolesAndAbilities.syncAbilities | train | protected function syncAbilities($abilities, $options = ['forbidden' => false])
{
$abilityKeys = $this->getAbilityIds($abilities);
$authority = $this->getAuthority();
$relation = $authority->abilities();
$this->newPivotQuery($relation)
->where('entity_type', $authority-... | php | {
"resource": ""
} |
q17227 | SyncsRolesAndAbilities.sync | train | protected function sync(array $ids, BelongsToMany $relation)
{
$current = $this->pluck(
$this->newPivotQuery($relation),
$this->getRelatedPivotKeyName($relation)
);
| php | {
"resource": ""
} |
q17228 | SyncsRolesAndAbilities.detach | train | public function detach(array $ids, BelongsToMany $relation)
{
if (empty($ids)) {
return;
| php | {
"resource": ""
} |
q17229 | SyncsRolesAndAbilities.newPivotQuery | train | protected function newPivotQuery(BelongsToMany $relation)
{
$query = $relation->newPivotStatement()->where(
$this->getForeignPivotKeyName($relation),
| php | {
"resource": ""
} |
q17230 | SyncsRolesAndAbilities.getForeignPivotKeyName | train | protected function getForeignPivotKeyName(BelongsToMany $relation)
{
if (method_exists($relation, 'getForeignPivotKeyName')) {
return $relation->getForeignPivotKeyName();
}
| php | {
"resource": ""
} |
q17231 | SyncsRolesAndAbilities.getRelatedPivotKeyName | train | protected function getRelatedPivotKeyName(BelongsToMany $relation)
{
if (method_exists($relation, 'getRelatedPivotKeyName')) {
return $relation->getRelatedPivotKeyName();
}
| php | {
"resource": ""
} |
q17232 | SyncsRolesAndAbilities.pluck | train | protected function pluck($query, $column)
{
| php | {
"resource": ""
} |
q17233 | AssignsRoles.to | train | public function to($authority)
{
$authorities = is_array($authority) ? $authority : [$authority];
$roles = Models::role()->findOrCreateRoles($this->roles);
| php | {
"resource": ""
} |
q17234 | AssignsRoles.assignRoles | train | protected function assignRoles(Collection $roles, $authorityClass, Collection $authorityIds)
{
$roleIds = $roles->map(function ($model) {
return $model->getKey();
});
| php | {
"resource": ""
} |
q17235 | AssignsRoles.getExistingAttachRecords | train | protected function getExistingAttachRecords($roleIds, $morphType, $authorityIds)
{
$query = $this->newPivotTableQuery()
->whereIn('role_id', $roleIds->all())
->whereIn('entity_id', $authorityIds->all())
| php | {
"resource": ""
} |
q17236 | AssignsRoles.buildAttachRecords | train | protected function buildAttachRecords($roleIds, $morphType, $authorityIds)
{
return $roleIds->map(function ($roleId) use ($morphType, $authorityIds) {
return $authorityIds->map(function ($authorityId) use ($roleId, $morphType) {
return Models::scope()->getAttachAttributes() + [
... | php | {
"resource": ""
} |
q17237 | AssignsRoles.createMissingAssignRecords | train | protected function createMissingAssignRecords(Collection $records, Collection $existing)
{
$existing = $existing->keyBy(function ($record) {
return $this->getAttachRecordHash((array) $record);
});
$records = $records->reject(function ($record) use ($existing) {
| php | {
"resource": ""
} |
q17238 | Bouncer.setClipboard | train | public function setClipboard(Contracts\Clipboard $clipboard)
{
$this->guard->setClipboard($clipboard);
| php | {
"resource": ""
} |
q17239 | Bouncer.registerClipboardAtContainer | train | public function registerClipboardAtContainer()
{
$clipboard = $this->guard->getClipboard();
| php | {
"resource": ""
} |
q17240 | Bouncer.cache | train | public function cache(Store $cache = null)
{
$cache = $cache ?: $this->resolve(CacheRepository::class)->getStore();
if ($this->usesCachedClipboard()) {
$this->guard->getClipboard()->setCache($cache);
| php | {
"resource": ""
} |
q17241 | Roles.constrainWhereIsAll | train | public function constrainWhereIsAll($query, $role)
{
$roles = array_slice(func_get_args(), 1);
return $query->whereHas('roles', function ($query) use ($roles) {
| php | {
"resource": ""
} |
q17242 | Roles.constrainWhereAssignedTo | train | public function constrainWhereAssignedTo($query, $model, array $keys = null)
{
list($model, $keys) = Helpers::extractModelAndKeys($model, $keys);
$query->whereExists(function ($query) use ($model, $keys) {
$table = $model->getTable();
$key = "{$table}.{$model->getKeyName... | php | {
"resource": ""
} |
q17243 | HasAbilities.abilities | train | public function abilities()
{
$relation = $this->morphToMany(
Models::classname(Ability::class),
| php | {
"resource": ""
} |
q17244 | HasAbilities.allow | train | public function allow($ability = null, $model = null)
{
if (is_null($ability)) {
| php | {
"resource": ""
} |
q17245 | HasAbilities.disallow | train | public function disallow($ability = null, $model = null)
{
if (is_null($ability)) {
| php | {
"resource": ""
} |
q17246 | HasAbilities.forbid | train | public function forbid($ability = null, $model = null)
{
if (is_null($ability)) {
| php | {
"resource": ""
} |
q17247 | HasAbilities.unforbid | train | public function unforbid($ability = null, $model = null)
{
if (is_null($ability)) {
return new UnforbidsAbilities($this);
| php | {
"resource": ""
} |
q17248 | AbilityTitle.isGeneralManagementAbility | train | protected function isGeneralManagementAbility(Model $ability)
{
return $ability->name === '*'
| php | {
"resource": ""
} |
q17249 | AbilityTitle.isBlanketModelAbility | train | protected function isBlanketModelAbility(Model $ability)
{
return $ability->name !== '*'
&& $ability->entity_type !== '*'
| php | {
"resource": ""
} |
q17250 | AbilityTitle.isSpecificModelAbility | train | protected function isSpecificModelAbility(Model $ability)
{
return $ability->entity_type !== | php | {
"resource": ""
} |
q17251 | AbilityTitle.isGlobalActionAbility | train | protected function isGlobalActionAbility(Model $ability)
{
return $ability->name !== | php | {
"resource": ""
} |
q17252 | AbilityTitle.getBlanketModelAbilityTitle | train | protected function getBlanketModelAbilityTitle(Model $ability, $name = 'manage')
| php | {
"resource": ""
} |
q17253 | AbilityTitle.getSpecificModelAbilityTitle | train | protected function getSpecificModelAbilityTitle(Model $ability)
{
$name = $ability->name === '*' ? 'manage' : $ability->name;
return $this->humanize(
| php | {
"resource": ""
} |
q17254 | Group.fromData | train | public static function fromData(array $data)
{
$group = new static(array_map(function ($data) {
return $data['class']::fromData($data['params']);
| php | {
"resource": ""
} |
q17255 | Group.equals | train | public function equals(Constrainer $constrainer)
{
if (! $constrainer instanceof static) {
return false;
}
if ($this->constraints->count() != $constrainer->constraints->count()) {
return false;
}
foreach ($this->constraints as | php | {
"resource": ""
} |
q17256 | Group.data | train | public function data()
{
return [
'class' => static::class,
'params' => [
'logicalOperator' => $this->logicalOperator,
| php | {
"resource": ""
} |
q17257 | BaseClipboard.check | train | public function check(Model $authority, $ability, $model = null) | php | {
"resource": ""
} |
q17258 | BaseClipboard.checkRole | train | public function checkRole(Model $authority, $roles, $boolean = 'or')
{
$count = $this->countMatchingRoles($authority, $roles);
if ($boolean == 'or') {
return $count > 0;
| php | {
"resource": ""
} |
q17259 | BaseClipboard.countMatchingRoles | train | protected function countMatchingRoles($authority, $roles)
{
$lookups = $this->getRolesLookup($authority);
return count(array_filter($roles, function ($role) use ($lookups) {
switch (true) {
case is_string($role):
return $lookups['names']->has($role);
... | php | {
"resource": ""
} |
q17260 | BaseClipboard.getAbilities | train | public function getAbilities(Model $authority, $allowed = true) | php | {
"resource": ""
} |
q17261 | Authorizable.can | train | public function can($ability, $model = null)
{
| php | {
"resource": ""
} |
q17262 | Guard.slot | train | public function slot($slot = null)
{
if (is_null($slot)) {
return $this->slot;
}
if (! in_array($slot, ['before', 'after'])) {
throw new InvalidArgumentException(
"{$slot} is | php | {
"resource": ""
} |
q17263 | Guard.registerAt | train | public function registerAt(Gate $gate)
{
$gate->before(function () {
return call_user_func_array([
$this, 'runBeforeCallback'
], func_get_args());
});
$gate->after(function () {
| php | {
"resource": ""
} |
q17264 | Guard.parseGateBeforeArguments | train | protected function parseGateBeforeArguments($arguments, $additional)
{
// The way arguments are passed into the gate's before callback has changed in Laravel
// in the middle of the 5.2 release. Before, arguments were spread out. Now they're
// all supplied in a single | php | {
"resource": ""
} |
q17265 | Guard.checkAtClipboard | train | protected function checkAtClipboard(Model $authority, $ability, $model)
{
if ($id = $this->clipboard->checkGetId($authority, $ability, $model)) {
return $this->allow('Bouncer granted permission via ability #'.$id);
}
// If the response from "checkGetId" is "false", then this abi... | php | {
"resource": ""
} |
q17266 | IsRole.bootIsRole | train | public static function bootIsRole()
{
BaseTenantScope::register(static::class);
static::creating(function ($role) {
Models::scope()->applyToModel($role);
if (is_null($role->title)) {
$role->title = RoleTitle::from($role)->toString();
| php | {
"resource": ""
} |
q17267 | IsRole.users | train | public function users()
{
$relation = $this->morphedByMany(
Models::classname(User::class),
| php | {
"resource": ""
} |
q17268 | IsRole.findOrCreateRoles | train | public function findOrCreateRoles($roles)
{
$roles = Helpers::groupModelsAndIdentifiersByType($roles);
$roles['integers'] = $this->find($roles['integers']);
| php | {
"resource": ""
} |
q17269 | IsRole.findOrCreateRolesByName | train | protected function findOrCreateRolesByName($names)
{
if (empty($names)) {
return [];
}
$existing = static::whereIn('name', $names)->get()->keyBy('name');
return (new Collection($names))
->diff($existing->pluck('name'))
| php | {
"resource": ""
} |
q17270 | IsRole.getRoleKeys | train | public function getRoleKeys($roles)
{
$roles = Helpers::groupModelsAndIdentifiersByType($roles);
$roles['strings'] = $this->getKeysByName($roles['strings']);
| php | {
"resource": ""
} |
q17271 | IsRole.getRoleNames | train | public function getRoleNames($roles)
{
$roles = Helpers::groupModelsAndIdentifiersByType($roles);
$roles['integers'] = $this->getNamesByKey($roles['integers']);
| php | {
"resource": ""
} |
q17272 | IsRole.getKeysByName | train | public function getKeysByName($names)
{
if (empty($names)) {
return [];
}
return $this->whereIn('name', $names)
| php | {
"resource": ""
} |
q17273 | IsRole.getNamesByKey | train | public function getNamesByKey($keys)
{
if (empty($keys)) {
return [];
}
return $this->whereIn($this->getKeyName(), $keys)
| php | {
"resource": ""
} |
q17274 | IsRole.createAssignRecords | train | protected function createAssignRecords(Model $model, array $keys)
{
$type = $model->getMorphClass();
return array_map(function ($key) use ($type) {
return Models::scope()->getAttachAttributes() + [
'role_id' | php | {
"resource": ""
} |
q17275 | IsRole.scopeWhereAssignedTo | train | public function scopeWhereAssignedTo($query, $model, array $keys = | php | {
"resource": ""
} |
q17276 | ConductsAbilities.shouldConductLazy | train | protected function shouldConductLazy($abilities)
{
// We'll only create a lazy conductor if we got a single
// param, and that single param is either a string or
// a numerically-indexed array (of simple strings).
if (func_num_args() > 1) {
return false;
}
... | php | {
"resource": ""
} |
q17277 | CleanCommand.getComputedOptions | train | protected function getComputedOptions()
{
$unassigned = $this->option('unassigned');
$orphaned = $this->option('orphaned');
if (! $unassigned && ! $orphaned) {
| php | {
"resource": ""
} |
q17278 | CleanCommand.deleteUnassignedAbilities | train | protected function deleteUnassignedAbilities()
{
$query = $this->getUnassignedAbilitiesQuery();
if (($count = $query->count()) > 0) | php | {
"resource": ""
} |
q17279 | CleanCommand.getUnassignedAbilitiesQuery | train | protected function getUnassignedAbilitiesQuery()
{
$model = Models::ability();
return $model->whereNotIn($model->getKeyName(), | php | {
"resource": ""
} |
q17280 | CleanCommand.deleteOrphanedAbilities | train | protected function deleteOrphanedAbilities()
{
$query = $this->getBaseOrphanedQuery()->where(function ($query) {
foreach ($this->getEntityModels() as $modelName) {
$query->orWhere(function ($query) use ($modelName) {
$this->scopeQueryToWhereModelIsMissing($que... | php | {
"resource": ""
} |
q17281 | CleanCommand.scopeQueryToWhereModelIsMissing | train | protected function scopeQueryToWhereModelIsMissing($query, $modelName)
{
$model = new $modelName;
$table = $this->abilitiesTable();
$query->where("{$table}.entity_type", $modelName);
| php | {
"resource": ""
} |
q17282 | GivesAbilities.to | train | public function to($abilities, $model = null, array $attributes = [])
{
if (call_user_func_array([$this, 'shouldConductLazy'], func_get_args())) {
| php | {
"resource": ""
} |
q17283 | GivesAbilities.giveAbilities | train | protected function giveAbilities(array $ids, Model $authority = null)
{
$ids = array_diff($ids, $this->getAssociatedAbilityIds($authority, $ids, false));
if (is_null($authority)) {
| php | {
"resource": ""
} |
q17284 | GivesAbilities.giveAbilitiesToAuthority | train | protected function giveAbilitiesToAuthority(array $ids, Model $authority)
{
$attributes | php | {
"resource": ""
} |
q17285 | GivesAbilities.giveAbilitiesToEveryone | train | protected function giveAbilitiesToEveryone(array $ids)
{
$attributes = Models::scope()->getAttachAttributes();
$records = array_map(function ($id) use ($attributes) {
| php | {
"resource": ""
} |
q17286 | ScopeBouncer.handle | train | public function handle($request, Closure $next)
{
// Here you may use whatever mechanism you use in your app
// to determine the current tenant. To | php | {
"resource": ""
} |
q17287 | Models.scope | train | public static function scope(ScopeContract $scope = null)
{
if (! is_null($scope)) {
return static::$scope = $scope;
}
| php | {
"resource": ""
} |
q17288 | Models.updateMorphMap | train | public static function updateMorphMap($classNames = null)
{
if (is_null($classNames)) {
$classNames = [ | php | {
"resource": ""
} |
q17289 | Models.isOwnedBy | train | public static function isOwnedBy(Model $authority, Model $model)
{
$type = get_class($model);
if (isset(static::$ownership[$type])) {
$attribute = static::$ownership[$type];
} elseif (isset(static::$ownership['*'])) {
$attribute = static::$ownership['*'];
} | php | {
"resource": ""
} |
q17290 | Models.isOwnedVia | train | protected static function isOwnedVia($attribute, Model $authority, Model $model)
{
if ($attribute instanceof Closure) {
return $attribute($model, $authority); | php | {
"resource": ""
} |
q17291 | Models.query | train | public static function query($table)
{
$query = new Builder(
$connection = static::user()->getConnection(),
$connection->getQueryGrammar(),
| php | {
"resource": ""
} |
q17292 | HandlesOwnership.to | train | public function to($ability, array $attributes = [])
{
$this->ability = $ability;
| php | {
"resource": ""
} |
q17293 | FindsAndCreatesAbilities.getAbilityIds | train | protected function getAbilityIds($abilities, $model = null, array $attributes = [])
{
if ($abilities instanceof Model) {
return [$abilities->getKey()];
}
if ( ! is_null($model)) {
return $this->getModelAbilityKeys($abilities, $model, $attributes);
}
... | php | {
"resource": ""
} |
q17294 | FindsAndCreatesAbilities.getAbilityIdsFromMap | train | protected function getAbilityIdsFromMap(array $map, array $attributes)
{
list($map, $list) = Helpers::partition($map, function ($value, $key) {
return ! is_int($key);
});
return $map->map(function ($entity, $ability) use ($attributes) {
| php | {
"resource": ""
} |
q17295 | FindsAndCreatesAbilities.getAbilityIdsFromArray | train | protected function getAbilityIdsFromArray($abilities, array $attributes)
{
$groups = Helpers::groupModelsAndIdentifiersByType($abilities);
$keyName = Models::ability()->getKeyName();
$groups['strings'] = $this->abilitiesByName($groups['strings'], $attributes)
| php | {
"resource": ""
} |
q17296 | FindsAndCreatesAbilities.getModelAbilityKeys | train | protected function getModelAbilityKeys($abilities, $model, array $attributes)
{
$abilities = Collection::make(is_array($abilities) ? $abilities : [$abilities]);
$models = Collection::make(is_array($model) ? $model : [$model]);
return $abilities->map(function ($ability) use ($models, $attri... | php | {
"resource": ""
} |
q17297 | FindsAndCreatesAbilities.getModelAbility | train | protected function getModelAbility($ability, $entity, array $attributes)
{
$entity = $this->getEntityInstance($entity);
| php | {
"resource": ""
} |
q17298 | FindsAndCreatesAbilities.findAbility | train | protected function findAbility($ability, $entity, $attributes)
{
$onlyOwned = isset($attributes['only_owned']) ? $attributes['only_owned'] : false;
$query = Models::ability()
->where('name', $ability)
| php | {
"resource": ""
} |
q17299 | FindsAndCreatesAbilities.createAbility | train | protected function createAbility($ability, $entity, $attributes)
{
| php | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.