_id stringlengths 2 7 | title stringlengths 3 151 | partition stringclasses 3
values | text stringlengths 83 13k | 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 {
$map[Models::classname(User::c... | php | {
"resource": ""
} |
q17201 | Helpers.partition | train | public static function partition($items, callable $callback)
{
$partitions = [new Collection, new Collection];
foreach ($items as $key => $item) {
$partitions[(int) ! $callback($item, $key)][$key] = $item;
}
return new Collection($partitions);
} | php | {
"resource": ""
} |
q17202 | Scope.applyToModel | train | public function applyToModel(Model $model)
{
if (! $this->onlyScopeRelations && ! is_null($this->scope)) {
$model->scope = $this->scope;
}
return $model;
} | 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)) {
$table = $query->getModel()->getTable();
}
return $this->applyToQuery($query, $table);
} | php | {
"resource": ""
} |
q17204 | Scope.applyToRelationQuery | train | public function applyToRelationQuery($query, $table)
{
if (is_null($this->scope)) {
return $query;
}
return $this->applyToQuery($query, $table);
} | php | {
"resource": ""
} |
q17205 | Scope.applyToRelation | train | public function applyToRelation(BelongsToMany $relation)
{
$this->applyToRelationQuery(
$relation->getQuery(),
$relation->getTable()
);
return $relation;
} | php | {
"resource": ""
} |
q17206 | Scope.applyToQuery | train | protected function applyToQuery($query, $table)
{
return $query->where(function ($query) use ($table) {
$query->where("{$table}.scope", $this->scope)
->orWhereNull("{$table}.scope");
});
} | php | {
"resource": ""
} |
q17207 | Scope.getAttachAttributes | train | public function getAttachAttributes($authority = null)
{
if (is_null($this->scope)) {
return [];
}
if (! $this->scopeRoleAbilities && $this->isRoleClass($authority)) {
return [];
}
return ['scope' => $this->scope];
} | php | {
"resource": ""
} |
q17208 | Scope.onceTo | train | public function onceTo($scope, callable $callback)
{
$mainScope = $this->scope;
$this->scope = $scope;
$result = $callback();
$this->scope = $mainScope;
return $result;
} | php | {
"resource": ""
} |
q17209 | BouncerServiceProvider.registerBouncer | train | protected function registerBouncer()
{
$this->app->singleton(Bouncer::class, function () {
return Bouncer::make()
->withClipboard(new CachedClipboard(new ArrayStore))
->withGate($this->app->make(Gate::class))
->create();
});
} | php | {
"resource": ""
} |
q17210 | BouncerServiceProvider.getTablePrefix | train | protected function getTablePrefix()
{
$config = $this->app->config['database'];
$connection = array_get($config, 'default');
return array_get($config, "connections.{$connection}.prefix");
} | 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));
$query->orWhereExists(static::getAuthorityConstraint($authorit... | 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)
->whereExists(static::getAuthorityRoleConstr... | 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())) {
return $this->conductLazy($abilities);
}
if ($ids = $this->getAbilityIds($abilities, $entity, $attributes)) {
$this->di... | php | {
"resource": ""
} |
q17218 | DisassociatesAbilities.disassociateAbilities | train | protected function disassociateAbilities($authority, array $ids)
{
if (is_null($authority)) {
$this->disassociateEveryone($ids);
} else {
$this->disassociateAuthority($authority, $ids);
}
} | php | {
"resource": ""
} |
q17219 | DisassociatesAbilities.disassociateAuthority | train | protected function disassociateAuthority(Model $authority, array $ids)
{
$this->getAbilitiesPivotQuery($authority, $ids)
->where($this->constraints())
->delete();
} | 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')
->where($this->constraints())
->whereIn('ability_id', $ids);
Models::scope()->applyToRelationQuery($query, $query->from);
$query->delete(... | php | {
"resource": ""
} |
q17223 | DisassociatesAbilities.getAuthority | train | protected function getAuthority()
{
if (is_null($this->authority)) {
return null;
}
if ($this->authority instanceof Model) {
return $this->authority;
}
return Models::role()->where('name', $this->authority)->firstOrFail();
} | 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),
$this->authority->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)
);
$this->detach(array_diff($current, $ids), $relation);
$relation->attach(
array_di... | php | {
"resource": ""
} |
q17228 | SyncsRolesAndAbilities.detach | train | public function detach(array $ids, BelongsToMany $relation)
{
if (empty($ids)) {
return;
}
$this->newPivotQuery($relation)
->whereIn($this->getRelatedPivotKeyName($relation), $ids)
->delete();
} | php | {
"resource": ""
} |
q17229 | SyncsRolesAndAbilities.newPivotQuery | train | protected function newPivotQuery(BelongsToMany $relation)
{
$query = $relation->newPivotStatement()->where(
$this->getForeignPivotKeyName($relation),
$relation->getParent()->getKey()
);
return Models::scope()->applyToRelationQuery(
$query, $relation->getT... | php | {
"resource": ""
} |
q17230 | SyncsRolesAndAbilities.getForeignPivotKeyName | train | protected function getForeignPivotKeyName(BelongsToMany $relation)
{
if (method_exists($relation, 'getForeignPivotKeyName')) {
return $relation->getForeignPivotKeyName();
}
if (method_exists($relation, 'getQualifiedForeignKeyName')) {
return $relation->getQualifiedFo... | php | {
"resource": ""
} |
q17231 | SyncsRolesAndAbilities.getRelatedPivotKeyName | train | protected function getRelatedPivotKeyName(BelongsToMany $relation)
{
if (method_exists($relation, 'getRelatedPivotKeyName')) {
return $relation->getRelatedPivotKeyName();
}
if (method_exists($relation, 'getQualifiedRelatedKeyName')) {
return $relation->getQualifiedRe... | php | {
"resource": ""
} |
q17232 | SyncsRolesAndAbilities.pluck | train | protected function pluck($query, $column)
{
return Arr::pluck($query->get([$column]), last(explode('.', $column)));
} | php | {
"resource": ""
} |
q17233 | AssignsRoles.to | train | public function to($authority)
{
$authorities = is_array($authority) ? $authority : [$authority];
$roles = Models::role()->findOrCreateRoles($this->roles);
foreach (Helpers::mapAuthorityByClass($authorities) as $class => $ids) {
$this->assignRoles($roles, $class, new Collection... | php | {
"resource": ""
} |
q17234 | AssignsRoles.assignRoles | train | protected function assignRoles(Collection $roles, $authorityClass, Collection $authorityIds)
{
$roleIds = $roles->map(function ($model) {
return $model->getKey();
});
$morphType = (new $authorityClass)->getMorphClass();
$records = $this->buildAttachRecords($roleIds, $mo... | 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())
->where('entity_type', $morphType);
Models::scope()->applyTo... | 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) {
retur... | php | {
"resource": ""
} |
q17238 | Bouncer.setClipboard | train | public function setClipboard(Contracts\Clipboard $clipboard)
{
$this->guard->setClipboard($clipboard);
return $this->registerClipboardAtContainer();
} | php | {
"resource": ""
} |
q17239 | Bouncer.registerClipboardAtContainer | train | public function registerClipboardAtContainer()
{
$clipboard = $this->guard->getClipboard();
Container::getInstance()->instance(Contracts\Clipboard::class, $clipboard);
return $this;
} | 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);
return $this;
}
return $this->setClipboard(new CachedClip... | 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) {
$query->whereIn('name', $roles);
}, '=', count($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),
'entity',
Models::table('permissions')
)->withPivot('forbidden', 'scope');
return Models::scope()->applyToRelation($relation);
} | php | {
"resource": ""
} |
q17244 | HasAbilities.allow | train | public function allow($ability = null, $model = null)
{
if (is_null($ability)) {
return new GivesAbilities($this);
}
(new GivesAbilities($this))->to($ability, $model);
return $this;
} | php | {
"resource": ""
} |
q17245 | HasAbilities.disallow | train | public function disallow($ability = null, $model = null)
{
if (is_null($ability)) {
return new RemovesAbilities($this);
}
(new RemovesAbilities($this))->to($ability, $model);
return $this;
} | php | {
"resource": ""
} |
q17246 | HasAbilities.forbid | train | public function forbid($ability = null, $model = null)
{
if (is_null($ability)) {
return new ForbidsAbilities($this);
}
(new ForbidsAbilities($this))->to($ability, $model);
return $this;
} | php | {
"resource": ""
} |
q17247 | HasAbilities.unforbid | train | public function unforbid($ability = null, $model = null)
{
if (is_null($ability)) {
return new UnforbidsAbilities($this);
}
(new UnforbidsAbilities($this))->to($ability, $model);
return $this;
} | php | {
"resource": ""
} |
q17248 | AbilityTitle.isGeneralManagementAbility | train | protected function isGeneralManagementAbility(Model $ability)
{
return $ability->name === '*'
&& $ability->entity_type !== '*'
&& ! is_null($ability->entity_type)
&& is_null($ability->entity_id);
} | php | {
"resource": ""
} |
q17249 | AbilityTitle.isBlanketModelAbility | train | protected function isBlanketModelAbility(Model $ability)
{
return $ability->name !== '*'
&& $ability->entity_type !== '*'
&& ! is_null($ability->entity_type)
&& is_null($ability->entity_id);
} | php | {
"resource": ""
} |
q17250 | AbilityTitle.isSpecificModelAbility | train | protected function isSpecificModelAbility(Model $ability)
{
return $ability->entity_type !== '*'
&& ! is_null($ability->entity_type)
&& ! is_null($ability->entity_id);
} | php | {
"resource": ""
} |
q17251 | AbilityTitle.isGlobalActionAbility | train | protected function isGlobalActionAbility(Model $ability)
{
return $ability->name !== '*'
&& $ability->entity_type === '*'
&& is_null($ability->entity_id);
} | php | {
"resource": ""
} |
q17252 | AbilityTitle.getBlanketModelAbilityTitle | train | protected function getBlanketModelAbilityTitle(Model $ability, $name = 'manage')
{
return $this->humanize($name.' '.$this->getPluralName($ability->entity_type));
} | php | {
"resource": ""
} |
q17253 | AbilityTitle.getSpecificModelAbilityTitle | train | protected function getSpecificModelAbilityTitle(Model $ability)
{
$name = $ability->name === '*' ? 'manage' : $ability->name;
return $this->humanize(
$name.' '.$this->basename($ability->entity_type).' #'.$ability->entity_id
);
} | 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']);
}, $data['constraints']));
return $group->logicalOperator($data['logicalOperator']);
} | 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 $index => $constraint) ... | php | {
"resource": ""
} |
q17256 | Group.data | train | public function data()
{
return [
'class' => static::class,
'params' => [
'logicalOperator' => $this->logicalOperator,
'constraints' => $this->constraints->map(function ($constraint) {
return $constraint->data();
})-... | php | {
"resource": ""
} |
q17257 | BaseClipboard.check | train | public function check(Model $authority, $ability, $model = null)
{
return (bool) $this->checkGetId($authority, $ability, $model);
} | 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;
} elseif ($boolean === 'not') {
return $count === 0;
}
return $count == count((a... | 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)
{
return Abilities::forAuthority($authority, $allowed)->get();
} | php | {
"resource": ""
} |
q17261 | Authorizable.can | train | public function can($ability, $model = null)
{
return $this->getClipboardInstance()->check($this, $ability, $model);
} | 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 an invalid gate slot"
);
}
$this->slot = $slot;... | 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 () {
return call_user_func_array([
$this, 'runAfte... | 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 array instead. We will... | 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),
'entity',
Models::table('assigned_roles')
)->withPivot('scope');
return Models::scope()->applyToRelation($relation);
} | php | {
"resource": ""
} |
q17268 | IsRole.findOrCreateRoles | train | public function findOrCreateRoles($roles)
{
$roles = Helpers::groupModelsAndIdentifiersByType($roles);
$roles['integers'] = $this->find($roles['integers']);
$roles['strings'] = $this->findOrCreateRolesByName($roles['strings']);
return $this->newCollection(Arr::collapse($roles));
... | 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'))
->map(function ($na... | php | {
"resource": ""
} |
q17270 | IsRole.getRoleKeys | train | public function getRoleKeys($roles)
{
$roles = Helpers::groupModelsAndIdentifiersByType($roles);
$roles['strings'] = $this->getKeysByName($roles['strings']);
$roles['models'] = Arr::pluck($roles['models'], $this->getKeyName());
return Arr::collapse($roles);
} | php | {
"resource": ""
} |
q17271 | IsRole.getRoleNames | train | public function getRoleNames($roles)
{
$roles = Helpers::groupModelsAndIdentifiersByType($roles);
$roles['integers'] = $this->getNamesByKey($roles['integers']);
$roles['models'] = Arr::pluck($roles['models'], 'name');
return Arr::collapse($roles);
} | php | {
"resource": ""
} |
q17272 | IsRole.getKeysByName | train | public function getKeysByName($names)
{
if (empty($names)) {
return [];
}
return $this->whereIn('name', $names)
->select($this->getKeyName())->get()
->pluck($this->getKeyName())->all();
} | php | {
"resource": ""
} |
q17273 | IsRole.getNamesByKey | train | public function getNamesByKey($keys)
{
if (empty($keys)) {
return [];
}
return $this->whereIn($this->getKeyName(), $keys)
->select('name')->get()
->pluck('name')->all();
} | 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' => $this->getKey(),
'entity_type' => $type,... | php | {
"resource": ""
} |
q17275 | IsRole.scopeWhereAssignedTo | train | public function scopeWhereAssignedTo($query, $model, array $keys = null)
{
(new RolesQuery)->constrainWhereAssignedTo($query, $model, $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) {
$unassigned = $orphaned = true;
}
return [$unassigned, $orphaned];
} | php | {
"resource": ""
} |
q17278 | CleanCommand.deleteUnassignedAbilities | train | protected function deleteUnassignedAbilities()
{
$query = $this->getUnassignedAbilitiesQuery();
if (($count = $query->count()) > 0) {
$query->delete();
$this->info("Deleted {$count} unassigned ".Str::plural('ability', $count).'.');
} else {
$this->info('... | php | {
"resource": ""
} |
q17279 | CleanCommand.getUnassignedAbilitiesQuery | train | protected function getUnassignedAbilitiesQuery()
{
$model = Models::ability();
return $model->whereNotIn($model->getKeyName(), function ($query) {
$query->from(Models::table('permissions'))->select('ability_id');
});
} | 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);
$query->whereNotIn("{$table}.entity_id", function ($query) use ($modelName) {
$model = ... | php | {
"resource": ""
} |
q17282 | GivesAbilities.to | train | public function to($abilities, $model = null, array $attributes = [])
{
if (call_user_func_array([$this, 'shouldConductLazy'], func_get_args())) {
return $this->conductLazy($abilities);
}
$ids = $this->getAbilityIds($abilities, $model, $attributes);
$this->giveAbilities... | 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)) {
$this->giveAbilitiesToEveryone($ids);
} else {
$this->giveAbilitiesToAuthority($ids, $... | php | {
"resource": ""
} |
q17284 | GivesAbilities.giveAbilitiesToAuthority | train | protected function giveAbilitiesToAuthority(array $ids, Model $authority)
{
$attributes = Models::scope()->getAttachAttributes(get_class($authority));
$authority->abilities()->attach($ids, $attributes);
} | php | {
"resource": ""
} |
q17285 | GivesAbilities.giveAbilitiesToEveryone | train | protected function giveAbilitiesToEveryone(array $ids)
{
$attributes = Models::scope()->getAttachAttributes();
$records = array_map(function ($id) use ($attributes) {
return ['ability_id' => $id] + $attributes;
}, $ids);
Models::query('permissions')->insert($records);
... | 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 demonstrate, the
// $tenantId is set here from the user's account_id.
$tenantId = $request->user()->account_id;
$this->bouncer-... | php | {
"resource": ""
} |
q17287 | Models.scope | train | public static function scope(ScopeContract $scope = null)
{
if (! is_null($scope)) {
return static::$scope = $scope;
}
if (is_null(static::$scope)) {
static::$scope = new Scope;
}
return static::$scope;
} | php | {
"resource": ""
} |
q17288 | Models.updateMorphMap | train | public static function updateMorphMap($classNames = null)
{
if (is_null($classNames)) {
$classNames = [
static::classname(Role::class),
static::classname(Ability::class),
];
}
Relation::morphMap($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['*'];
} e... | php | {
"resource": ""
} |
q17290 | Models.isOwnedVia | train | protected static function isOwnedVia($attribute, Model $authority, Model $model)
{
if ($attribute instanceof Closure) {
return $attribute($model, $authority);
}
return $authority->getKey() == $model->{$attribute};
} | php | {
"resource": ""
} |
q17291 | Models.query | train | public static function query($table)
{
$query = new Builder(
$connection = static::user()->getConnection(),
$connection->getQueryGrammar(),
$connection->getPostProcessor()
);
return $query->from(static::table($table));
} | php | {
"resource": ""
} |
q17292 | HandlesOwnership.to | train | public function to($ability, array $attributes = [])
{
$this->ability = $ability;
$this->attributes = array_merge($this->attributes, $attributes);
} | 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) {
return $this->getAbilityIds($a... | 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);
$existing = $this->findAbility($ability, $entity, $attributes);
return $existing ?: $this->createAbility($ability, $entity, $attributes);
} | 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)
->forModel($entity, true)
->where('... | php | {
"resource": ""
} |
q17299 | FindsAndCreatesAbilities.createAbility | train | protected function createAbility($ability, $entity, $attributes)
{
return Models::ability()->createForModel($entity, $attributes + [
'name' => $ability,
]);
} | php | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.