AuthorizationPolicy
extends BasePolicy
in package
Authorization Policy for Member Activity Authorizations
This policy class defines authorization rules for Authorization entity operations within the KMP Activities plugin. It provides comprehensive access control for member authorization requests, approvals, and lifecycle management with both self-service capabilities and administrative oversight.
Purpose:
- Controls access to Authorization entity operations through permission-based and ownership-based rules
- Provides self-service authorization for members managing their own activity authorizations
- Ensures proper administrative oversight for authorization workflows and approval processes
- Integrates with KMP's RBAC system for authorization management and approval authority validation
Authorization Architecture:
- Dual Authorization Model: Combines ownership-based and permission-based authorization
- Self-Service Access: Members can manage their own authorization requests and renewals
- Administrative Control: Permission-based access for administrative and approval operations
- Policy Framework Integration: Dynamic policy evaluation through permission policy associations
Key Features:
- Ownership Validation: Members have full access to their own authorization records
- Permission Integration: Administrative operations require appropriate permissions
- Approval Authority: Integration with activity-specific approval permission requirements
- Workflow Security: Proper access control for authorization lifecycle management
- Audit Trail Support: Authorization tracking with proper access control for historical data
Access Control Patterns:
- Member Self-Service: Direct access for own authorization requests and renewals
- Administrative Oversight: Permission-based access for authorization management
- Approval Authority: Activity-specific permissions for authorization approval operations
- Reporting Access: Controlled access to authorization statistics and reporting data
Integration Points:
- PermissionsLoader: Core permission validation and warrant checking for administrative access
- BasePolicy: Inherited permission discovery and policy framework integration
- Authorization Controllers: Access control for authorization workflow interfaces
- Activity System: Integration with activity-specific approval requirements and permissions
Security Considerations:
- Members maintain privacy and control over their own authorization records
- Administrative access requires appropriate permission validation through RBAC system
- Approval operations integrate with activity-specific permission requirements
- Authorization viewing includes proper scope limitations for organizational privacy
Tags
Table of Contents
Methods
- activityAuthorizations() : bool
- Check if the user can view authorizations for a specific activity.
- before() : bool|null
- Check if $user is a super user and can skip auth with an auto True
- canAdd() : bool
- Check if the user can add an authorization request.
- canDelete() : bool
- Check if $user can delete RolesPermissions
- canEdit() : bool
- Check if $user can edit RolesPermissions
- canGridData() : bool
- Check if $user can view role
- canIndex() : bool
- Check if $user can view role
- canMemberAuthorizations() : bool
- Check if the user can view a specific member's authorizations.
- canRenew() : bool
- Check if the user can request a renewal of an authorization.
- canRetract() : bool
- Check if the user can retract an authorization request.
- canRevoke() : bool
- Check if the user can revoke an authorization.
- canView() : bool
- Check if $user can view RolesPermissions
- canViewPrivateNotes() : bool
- Check if $user can view hidden
- scopeIndex() : mixed
- Apply scope for index action.
- _getBranchIdsForPolicy() : array<string|int, mixed>|null
- Check if $user can view hidden
- _getPermissions() : bool
- Check if $user can view hidden
- _getPolicies() : bool
- Check if $user can view hidden
- _hasPolicy() : bool
- Check if $user can view hidden
- _hasPolicyForUrl() : bool
- Check if $user can view hidden
- _isSuperUser() : bool
- Check if $user is a super user
- canManageAuthorizationMember() : bool
- Determine whether the user can manage authorization actions for a member.
Methods
activityAuthorizations()
Check if the user can view authorizations for a specific activity.
public
activityAuthorizations(KmpIdentityInterface $user, Authorization $entity, mixed ...$optionalArgs) : bool
Determines authorization for viewing activity-specific authorization lists and statistics, implementing dual access control with member self-service capabilities and administrative oversight.
Authorization Logic:
- Self-Service Access: Members can view their own authorizations within activity context
- Administrative Access: Users with appropriate permissions can view all activity authorizations
- Permission Validation: Delegates to permission-based policy evaluation for administrative access
Activity-Focused Viewing:
- Provides activity-centric view of authorization data for administrative management
- Supports activity-specific reporting and oversight workflows
- Enables activity administrators to monitor participation and approval status
Permission-Based Access: For administrative operations, typically requires permissions such as:
- "Activities.viewActivityAuthorizations": Authority to view activity-specific authorization lists
- "Activities.manage": General authorization management and oversight capabilities
- Activity-specific permissions: Based on the activity's permission requirements
- Branch-scoped permissions: Organizational boundaries for activity authorization visibility
Usage Examples:
// Activity administrator viewing authorization status
if ($this->Authorization->can($user, 'activityAuthorizations', $authorization)) {
$activityAuthorizations = $this->getActivityAuthorizationsQuery($activityId);
}
// Activity-specific reporting and analytics
$this->Authorization->authorize($authorization, 'activityAuthorizations');
Integration Points:
- Activity management interfaces for authorization oversight
- Administrative reporting dashboards with activity-focused data
- Approval workflow management for activity-specific processes
- Activity statistics and participation tracking
Security Considerations:
- Activity authorization data may reveal organizational structure and member qualifications
- Administrative access requires proper permission validation and audit trail
- Integration with activity-specific permission requirements for granular access control
Parameters
- $user : KmpIdentityInterface
-
The requesting user
- $entity : Authorization
-
The authorization entity
- $optionalArgs : mixed
-
Additional arguments for policy evaluation
Tags
Return values
bool —True if user can view activity authorizations, false otherwise
before()
Check if $user is a super user and can skip auth with an auto True
public
before(KmpIdentityInterface $user, mixed $resource, string $action) : bool|null
Parameters
- $user : KmpIdentityInterface
-
The user.
- $resource : mixed
-
The resource.
- $action : string
-
The action.
Return values
bool|nullcanAdd()
Check if the user can add an authorization request.
public
canAdd(KmpIdentityInterface $user, Authorization|Table $entity, mixed ...$optionalArgs) : bool
Determines authorization for creating new authorization requests, implementing dual access control with member self-service capabilities and administrative override authority.
Authorization Logic:
- Self-Service Access: Members can request authorizations for themselves
- Administrative Access: Users with appropriate permissions can request on behalf of others
- Permission Validation: Delegates to permission-based policy evaluation for administrative operations
Ownership-Based Access:
- Direct access when
entity->member_idmatches requesting user's ID - Enables self-service authorization request workflows
- Supports member autonomy in authorization management
Permission-Based Access: For administrative operations, typically requires permissions such as:
- "Activities.request": Authority to request authorizations for other members
- "Activities.manage": General authorization management capabilities
- Branch-scoped permissions: Organizational boundaries for authorization requests
Usage Examples:
// Member requesting own authorization
$authorization = $this->Authorizations->newEntity(['member_id' => $currentUser->id]);
$this->Authorization->authorize($authorization, 'add'); // Returns true for own request
// Administrative authorization request
$authorization = $this->Authorizations->newEntity(['member_id' => $targetMember->id]);
$this->Authorization->authorize($authorization, 'add'); // Requires permission validation
Security Considerations:
- Self-service access maintains member autonomy while ensuring proper identity verification
- Administrative access requires appropriate permission validation through RBAC system
- Integration with warrant system for temporal validation of administrative authority
Parameters
- $user : KmpIdentityInterface
-
The requesting user
- $entity : Authorization|Table
-
The authorization entity or table
- $optionalArgs : mixed
-
Additional arguments for policy evaluation
Tags
Return values
bool —True if user can add authorization request, false otherwise
canDelete()
Check if $user can delete RolesPermissions
public
canDelete(KmpIdentityInterface $user, BaseEntity $entity, mixed ...$optionalArgs) : bool
Parameters
- $user : KmpIdentityInterface
-
The user.
- $entity : BaseEntity
- $optionalArgs : mixed
Return values
boolcanEdit()
Check if $user can edit RolesPermissions
public
canEdit(KmpIdentityInterface $user, BaseEntity $entity, mixed ...$optionalArgs) : bool
Parameters
- $user : KmpIdentityInterface
-
The user.
- $entity : BaseEntity
- $optionalArgs : mixed
Return values
boolcanGridData()
Check if $user can view role
public
canGridData(KmpIdentityInterface $user, BaseEntity $entity, mixed ...$optionalArgs) : bool
Parameters
- $user : KmpIdentityInterface
-
The user.
- $entity : BaseEntity
- $optionalArgs : mixed
Return values
boolcanIndex()
Check if $user can view role
public
canIndex(KmpIdentityInterface $user, BaseEntity $entity, mixed ...$optionalArgs) : bool
Parameters
- $user : KmpIdentityInterface
-
The user.
- $entity : BaseEntity
- $optionalArgs : mixed
Return values
boolcanMemberAuthorizations()
Check if the user can view a specific member's authorizations.
public
canMemberAuthorizations(KmpIdentityInterface $user, Authorization $entity, mixed ...$optionalArgs) : bool
Determines authorization for viewing member authorization lists and details, implementing dual access control with member self-service visibility and administrative oversight capabilities.
Authorization Logic:
- Self-Service Access: Members can view their own authorization records and history
- Administrative Access: Users with appropriate permissions can view authorizations for other members
- Permission Validation: Delegates to permission-based policy evaluation for administrative viewing
Ownership-Based Access:
- Direct access when
entity->member_idmatches requesting user's ID - Enables member privacy and control over their authorization information
- Supports self-service authorization status checking and renewal planning
Permission-Based Access: For administrative operations, typically requires permissions such as:
- "Activities.viewMemberAuthorizations": Authority to view member authorization records
- "Activities.manage": General authorization management and oversight capabilities
- "Reports.activities": Reporting and analysis access for authorization data
- Branch-scoped permissions: Organizational boundaries for member authorization visibility
Privacy and Security:
- Member authorization data includes sensitive information about qualifications and status
- Administrative access requires proper permission validation and audit trail
- Integration with branch scoping for organizational privacy boundaries
Usage Examples:
// Member viewing own authorizations
$this->Authorization->authorize($authorization, 'memberAuthorizations'); // Returns true for own records
// Administrative authorization review
if ($this->Authorization->can($user, 'memberAuthorizations', $authorization)) {
$authorizationsList = $this->getMemberAuthorizationsQuery($memberId);
}
Integration Points:
- Member profile interfaces for self-service authorization management
- Administrative reporting and oversight dashboards
- Authorization workflow interfaces for approval and renewal processes
Parameters
- $user : KmpIdentityInterface
-
The requesting user
- $entity : Authorization
-
The authorization entity
- $optionalArgs : mixed
-
Additional arguments for policy evaluation
Tags
Return values
bool —True if user can view member authorizations, false otherwise
canRenew()
Check if the user can request a renewal of an authorization.
public
canRenew(KmpIdentityInterface $user, Authorization $entity, mixed ...$optionalArgs) : bool
Determines authorization for renewing existing authorizations, implementing dual access control with member self-service renewal capabilities and administrative renewal authority.
Authorization Logic:
- Self-Service Renewal: Members can renew their own authorizations
- Administrative Renewal: Users with appropriate permissions can renew authorizations for others
- Permission Validation: Delegates to permission-based policy evaluation for administrative operations
Ownership-Based Access:
- Direct access when
entity->member_idmatches requesting user's ID - Enables self-service authorization renewal workflows
- Supports member autonomy in maintaining current authorizations
Permission-Based Access: For administrative operations, typically requires permissions such as:
- "Activities.renew": Authority to renew authorizations for other members
- "Activities.manage": General authorization management capabilities
- Activity-specific permissions: Based on the authorization's activity requirements
Renewal Context:
- Renewal requests typically maintain existing approval chains and requirements
- May have different approval requirements than initial authorization requests
- Supports continuous authorization maintenance for ongoing activities
Usage Examples:
// Member renewing own authorization
$this->Authorization->authorize($authorization, 'renew'); // Returns true for own authorization
// Administrative renewal for expired authorizations
if ($this->Authorization->can($user, 'renew', $authorization)) {
$authorizationManager->renew($authorization->id, $user->id);
}
Security Considerations:
- Self-service renewal maintains member control over their authorization lifecycle
- Administrative renewal requires appropriate permission validation and audit trail
- Integration with temporal validation for authorization expiration and renewal timing
Parameters
- $user : KmpIdentityInterface
-
The requesting user
- $entity : Authorization
-
The authorization entity
- $optionalArgs : mixed
-
Additional arguments for policy evaluation
Tags
Return values
bool —True if user can renew the authorization, false otherwise
canRetract()
Check if the user can retract an authorization request.
public
canRetract(KmpIdentityInterface $user, Authorization $entity, mixed ...$optionalArgs) : bool
Determines authorization for retracting pending authorization requests, implementing ownership-based access control to allow members to cancel their own pending requests.
Authorization Logic:
- Self-Service Retraction: Members can retract their own pending authorization requests
- Status Validation: Retraction only allowed for pending authorizations
- Ownership Requirement: Only the requesting member can retract
Ownership-Based Access:
- Direct access when
entity->member_idmatches requesting user's ID - Enables member autonomy in managing authorization workflow
- No administrative override - retraction is member-only action
Use Cases:
- Request sent to wrong approver
- Request no longer needed
- Stalled request with no response
- Incorrect activity requested
Usage Examples:
// Member retracting own pending authorization
$this->Authorization->authorize($authorization, 'retract'); // Returns true for own request
// Controller validation
if ($this->Authorization->can($user, 'retract', $authorization)) {
$authorizationManager->retract($authorization->id, $user->id);
}
Security Considerations:
- Retraction is strictly owner-only operation
- Maintains member privacy and control over authorization requests
- Does not require administrative permission validation
- Only applicable to pending requests, not approved authorizations
Parameters
- $user : KmpIdentityInterface
-
The requesting user
- $entity : Authorization
-
The authorization entity
- $optionalArgs : mixed
-
Additional arguments for policy evaluation
Return values
bool —True if user can retract the authorization, false otherwise
canRevoke()
Check if the user can revoke an authorization.
public
canRevoke(KmpIdentityInterface $user, Authorization $entity, mixed ...$optionalArgs) : bool
Determines authorization for revoking member activity authorizations, providing access control for administrative revocation operations and authorization lifecycle management.
Authorization Logic:
- Delegates to permission-based policy evaluation through BasePolicy
- Requires appropriate administrative permissions for revocation authority
- Integrates with Activities plugin permission policy framework
- Supports warrant-based temporal validation for administrative roles
Permission Requirements: Typically requires permissions such as:
- "Activities.revoke": Direct authorization revocation authority
- "Activities.manage": General authorization management capabilities
- Activity-specific permissions: Based on the authorization's activity requirements
Usage Examples:
// Controller authorization for revocation interface
$this->Authorization->authorize($authorization, 'revoke');
// Service-level authorization check
if ($this->Authorization->can($user, 'revoke', $authorization)) {
$authorizationManager->revoke($authorization->id, $user->id, $reason);
}
Security Considerations:
- Revocation is typically restricted to administrative users with appropriate authority
- Integration with audit trail system for accountability and compliance
- Warrant validation ensures temporal authority for revocation operations
Parameters
- $user : KmpIdentityInterface
-
The requesting user
- $entity : Authorization
-
The authorization entity
- $optionalArgs : mixed
-
Additional arguments for policy evaluation
Tags
Return values
bool —True if user can revoke the authorization, false otherwise
canView()
Check if $user can view RolesPermissions
public
canView(KmpIdentityInterface $user, BaseEntity|Table $entity, mixed ...$optionalArgs) : bool
Parameters
- $user : KmpIdentityInterface
-
The user.
- $entity : BaseEntity|Table
- $optionalArgs : mixed
Return values
boolcanViewPrivateNotes()
Check if $user can view hidden
public
canViewPrivateNotes(KmpIdentityInterface $user, BaseEntity $entity) : bool
Parameters
- $user : KmpIdentityInterface
-
The user.
- $entity : BaseEntity
Return values
boolscopeIndex()
Apply scope for index action.
public
scopeIndex(KmpIdentityInterface $user, mixed $query) : mixed
Parameters
- $user : KmpIdentityInterface
- $query : mixed
_getBranchIdsForPolicy()
Check if $user can view hidden
protected
_getBranchIdsForPolicy(KmpIdentityInterface $user, string $policyMethod) : array<string|int, mixed>|null
Parameters
- $user : KmpIdentityInterface
-
The user.
- $policyMethod : string
Return values
array<string|int, mixed>|null_getPermissions()
Check if $user can view hidden
protected
_getPermissions(KmpIdentityInterface $user) : bool
Parameters
- $user : KmpIdentityInterface
-
The user.
Return values
bool_getPolicies()
Check if $user can view hidden
protected
_getPolicies(KmpIdentityInterface $user) : bool
Parameters
- $user : KmpIdentityInterface
-
The user.
Return values
bool_hasPolicy()
Check if $user can view hidden
protected
_hasPolicy(KmpIdentityInterface $user, string $policyMethod, BaseEntity|Table $entity[, int|null $branchId = null ][, mixed $grantSource = null ]) : bool
Parameters
- $user : KmpIdentityInterface
-
The user.
- $policyMethod : string
- $entity : BaseEntity|Table
- $branchId : int|null = null
- $grantSource : mixed = null
Return values
bool_hasPolicyForUrl()
Check if $user can view hidden
protected
_hasPolicyForUrl(KmpIdentityInterface $user, string $policyMethod, array<string|int, mixed> $urlProps[, int|null $branchId = null ][, mixed $grantSource = null ]) : bool
Parameters
- $user : KmpIdentityInterface
-
The user.
- $policyMethod : string
- $urlProps : array<string|int, mixed>
- $branchId : int|null = null
- $grantSource : mixed = null
Return values
bool_isSuperUser()
Check if $user is a super user
protected
_isSuperUser(KmpIdentityInterface $user) : bool
Parameters
- $user : KmpIdentityInterface
-
The user.
Return values
boolcanManageAuthorizationMember()
Determine whether the user can manage authorization actions for a member.
protected
canManageAuthorizationMember(KmpIdentityInterface $user, int $memberId) : bool
Allows self or parent-of-minor access.
Parameters
- $user : KmpIdentityInterface
- $memberId : int