### Example Process Method for Laravel One-Time Operation

Source: https://github.com/timokoerber/laravel-one-time-operations/blob/main/README.md

An example demonstrating how to implement custom logic within the `process()` method of a Laravel one-time operation. This specific example updates the status of active users to 'awesome'.

```php
// operations/XXXX_XX_XX_XXXXXX_awesome_operation.php

public function process(): void
{
    User::where('active', 1)->update(['status' => 'awesome']) // make active users awesome
}

```

--------------------------------

### Example Deployment Script with Tagged Operations (Bash)

Source: https://context7.com/timokoerber/laravel-one-time-operations/llms.txt

An example deployment script demonstrating the use of tagged operations. It first processes operations tagged 'before-migrations', then runs database migrations, and finally processes any remaining operations.

```bash
# Deployment pipeline
php artisan operations:process --tag=before-migrations
php artisan migrate
php artisan operations:process  # Processes all remaining operations

```

--------------------------------

### Install Laravel One-Time Operations Package

Source: https://github.com/timokoerber/laravel-one-time-operations/blob/main/README.md

Installs the 'laravel-one-time-operations' package using Composer and creates the necessary database table via Artisan migration.

```shell
composer require timokoerber/laravel-one-time-operations
php artisan migrate
```

--------------------------------

### Integrate Operations into Deployment Pipeline

Source: https://context7.com/timokoerber/laravel-one-time-operations/llms.txt

This bash script demonstrates how to integrate one-time operations into a CI/CD deployment process. It includes steps for pulling code, installing dependencies, clearing caches, running tagged operations before migrations, executing database migrations, processing any remaining operations, and restarting queue workers.

```bash
#!/bin/bash
# deploy.sh - Example deployment script

# Pull latest code
git pull origin main

# Install dependencies
composer install --no-dev --optimize-autoloader

# Clear caches
php artisan config:cache
php artisan route:cache
php artisan view:cache

# Run pre-migration operations
php artisan operations:process --tag=before-migrations --sync

# Run database migrations
php artisan migrate --force

# Run all remaining operations (async by default)
php artisan operations:process

# Restart queue workers to pick up new jobs
php artisan queue:restart
```

--------------------------------

### Synchronous Operation Example (PHP)

Source: https://context7.com/timokoerber/laravel-one-time-operations/llms.txt

Example of a PHP class extending OneTimeOperation to perform a critical schema update synchronously. This operation blocks deployment until completion. It uses Laravel's DB facade within a transaction to ensure atomicity.

```php
<?php
// operations/2024_01_15_160000_critical_schema_update.php

use Illuminate\Support\Facades\DB;
use TimoKoerber\LaravelOneTimeOperations\OneTimeOperation;

return new class extends OneTimeOperation
{
    // Execute synchronously - blocks until complete
    protected bool $async = false;

    public function process(): void
    {
        DB::transaction(function () {
            // Critical update that must complete before app serves requests
            DB::table('settings')->where('key', 'api_version')->update([
                'value' => '2.0',
                'updated_at' => now(),
            ]);

            DB::table('feature_flags')->insert([
                'name' => 'new_api_enabled',
                'enabled' => true,
                'created_at' => now(),
            ]);
        });
    }
};

```

--------------------------------

### Programmatic Access to Operations with OneTimeOperationManager

Source: https://context7.com/timokoerber/laravel-one-time-operations/llms.txt

The `OneTimeOperationManager` class offers static methods for programmatic control over operations, ideal for custom scripts or testing. It can retrieve unprocessed or all operation files, get operation class instances or their corresponding models by name, check for the existence of operation files, and retrieve configuration details like the operations directory path and the database table name.

```php
<?php

use TimoKoerber\LaravelOneTimeOperations\OneTimeOperationManager;

// Get all unprocessed operation files
$pending = OneTimeOperationManager::getUnprocessedOperationFiles();
foreach ($pending as $operationFile) {
    echo $operationFile->getOperationName();  // '2024_01_15_150000_migrate_user_data'
}

// Get all operation files (regardless of status)
$allFiles = OneTimeOperationManager::getAllOperationFiles();

// Get operation class instance by name
$operation = OneTimeOperationManager::getClassObjectByName('2024_01_15_150000_migrate_user_data');
echo $operation->isAsync();     // true
echo $operation->getQueue();    // 'default'
echo $operation->getTag();      // 'user-migration'

// Get operation model by name
$model = OneTimeOperationManager::getModelByName('2024_01_15_143052_update_user_statuses');

// Check if operation file exists
$exists = OneTimeOperationManager::fileExistsByName('2024_01_15_143052_update_user_statuses');

// Get operations directory path
$directory = OneTimeOperationManager::getDirectoryPath();  // '/var/www/app/operations/'

// Get configured table name
$table = OneTimeOperationManager::getTableName();  // 'operations'
```

--------------------------------

### Show Operations with Filters using Shell

Source: https://github.com/timokoerber/laravel-one-time-operations/blob/main/README.md

The `operations:show` command lists all operations, with options to filter by their status: `pending`, `processed`, or `disposed`. This helps in managing and tracking the state of operations without direct database checks.

```shell
php artisan operations:show pending           // show only pending operations
```

```shell
php artisan operations:show pending disposed  // show only pending and disposed operations
```

--------------------------------

### Integrate Operations into Deployment Script

Source: https://github.com/timokoerber/laravel-one-time-operations/blob/main/README.md

Demonstrates how to include the one-time operations processing command in a deployment script, ensuring operations run after code deployment and database migrations.

```shell
...
 - php artisan migrate
 - php artisan operations:process
...
```

--------------------------------

### Show All Operations Status (Bash)

Source: https://context7.com/timokoerber/laravel-one-time-operations/llms.txt

Command to list all defined one-time operations and their current status: pending, processed, or disposed. This helps in monitoring the execution state of all operations.

```bash
# Show all operations
php artisan operations:show

# Output:
# 2024_01_15_143052_update_user_statuses ................ PROCESSED
# 2024_01_15_150000_migrate_user_data ................... PENDING
# 2024_01_10_120000_old_cleanup ......................... DISPOSED

```

--------------------------------

### Force Sync/Async Execution (Bash)

Source: https://context7.com/timokoerber/laravel-one-time-operations/llms.txt

Commands to override the default asynchronous behavior of operations. `--sync` forces all operations to run synchronously, while `--async` forces them to run asynchronously, regardless of their individual `$async` property settings.

```bash
# Force all operations to run synchronously (ignore $async setting)
php artisan operations:process --sync

# Force all operations to run asynchronously (ignore $async setting)
php artisan operations:process --async

```

--------------------------------

### Publish and Edit Configuration File

Source: https://github.com/timokoerber/laravel-one-time-operations/blob/main/README.md

Publishes the configuration file for the one-time operations package, allowing customization of the operations directory and database table name.

```shell
php artisan vendor:publish --provider="TimoKoerber\LaravelOneTimeOperations\Providers\OneTimeOperationsServiceProvider"
```

--------------------------------

### Create Custom Operation Templates

Source: https://context7.com/timokoerber/laravel-one-time-operations/llms.txt

You can define custom operation templates by creating a stub file named `one-time-operation.stub` in your project's root `/stubs` directory. This allows you to pre-configure properties like `$async`, `$queue`, and `$tag`, and to implement custom logic within the `process` method, including error handling and logging.

```php
<?php
// stubs/one-time-operation.stub

use App\Services\OperationLogger;
use TimoKoerber\LaravelOneTimeOperations\OneTimeOperation;

return new class extends OneTimeOperation
{
    protected bool $async = false;
    protected string $queue = 'operations';
    protected ?string $tag = null;

    public function process(): void
    {
        OperationLogger::start($this);

        try {
            $this->execute();
            OperationLogger::success($this);
        } catch (\Throwable $e) {
            OperationLogger::failure($this, $e);
            throw $e;
        }
    }

    private function execute(): void
    {
        // Operation logic here
    }
};

```

--------------------------------

### Run All Tests using Shell

Source: https://github.com/timokoerber/laravel-one-time-operations/blob/main/README.md

The `composer test` command is used to execute all the test suites for the package. This is a standard practice for ensuring the code base is functioning as expected.

```shell
composer test
```

--------------------------------

### Default Configuration for One-Time Operations

Source: https://github.com/timokoerber/laravel-one-time-operations/blob/main/README.md

The default configuration settings for the one-time operations package, specifying the directory for operation files and the name of the database table used to track processed operations.

```php
// config/one-time-operation.php

return [
    'directory' => 'operations',
    'table' => 'operations',
];
```

--------------------------------

### Configure Operation Class Properties

Source: https://context7.com/timokoerber/laravel-one-time-operations/llms.txt

Demonstrates how to configure properties within a `OneTimeOperation` class. This includes setting `$async` for asynchronous processing, `$queue` for dispatching jobs to a specific queue, and `$tag` for filtering operations.

```php
<?php
// operations/2024_01_15_150000_migrate_user_data.php

use App\Models\User;
use TimoKoerber\LaravelOneTimeOperations\OneTimeOperation;

return new class extends OneTimeOperation
{
    // Process asynchronously via queue (default: true)
    protected bool $async = true;

    // Target queue for async processing (default: 'default')
    protected string $queue = 'high-priority';

    // Tag for filtering during processing (default: null)
    protected ?string $tag = 'user-migration';

    public function process(): void
    {
        // Update all active users to new status format
        User::where('active', 1)->update([
            'status' => 'active',
            'migrated_at' => now(),
        ]);

        // Log completion for monitoring
        logger()->info('User migration completed', [
            'count' => User::where('status', 'active')->count()
        ]);
    }
};
```

--------------------------------

### Generated Essential One-Time Operation File

Source: https://context7.com/timokoerber/laravel-one-time-operations/llms.txt

A minimal template for a one-time operation file. It only includes the essential `process()` method, suitable for operations that do not require asynchronous processing, specific queues, or tags.

```php
<?php
// operations/2024_01_15_143052_update_user_statuses.php

use TimoKoerber\LaravelOneTimeOperations\OneTimeOperation;

return new class extends OneTimeOperation
{
    public function process(): void
    {
        //
    }
};
```

--------------------------------

### Create a New One-Time Operation File

Source: https://github.com/timokoerber/laravel-one-time-operations/blob/main/README.md

Generates a new operation class file for one-time execution using the Artisan command. Supports creating essential operations without additional attributes.

```shell
php artisan operations:make <operation_name>
php artisan operations:make <operation_name> -e|--essential
php artisan make:operation <operation_name>
```

--------------------------------

### Test Operations Repeatedly using Shell

Source: https://github.com/timokoerber/laravel-one-time-operations/blob/main/README.md

The `--test` flag allows for repeated execution of operations. This is beneficial during development to test an operation multiple times before marking it as processed, ensuring its reliability.

```shell
php artisan operations:process --test
```

--------------------------------

### Create Essential One-Time Operation File in Laravel

Source: https://github.com/timokoerber/laravel-one-time-operations/blob/main/README.md

Generates a simplified one-time operation file using the `--essential` or `-e` flag with the artisan command. This creates a cleaner file when not all default attributes are needed.

```shell
php artisan operations:make AwesomeOperation --essential
php artisan operations:make AwesomeOperation -e
```

--------------------------------

### Process One-Time Operations

Source: https://github.com/timokoerber/laravel-one-time-operations/blob/main/README.md

Executes all pending one-time operations. Supports various options for synchronous/asynchronous processing, testing, isolation, queue specification, tagging, and re-running specific operations.

```shell
php artisan operations:process
php artisan operations:process --sync
php artisan operations:process --async
php artisan operations:process --test
php artisan operations:process --isolated
php artisan operations:process --queue=<name>
php artisan operations:process --tag=<tagname>
php artisan operations:process <operation_name>
```

--------------------------------

### Generated Standard One-Time Operation File

Source: https://context7.com/timokoerber/laravel-one-time-operations/llms.txt

A template for a standard one-time operation file. It includes properties for asynchronous processing, queue assignment, and tag filtering, along with the required `process()` method for defining the operation's logic.

```php
<?php
// operations/2024_01_15_143052_update_user_statuses.php

use TimoKoerber\LaravelOneTimeOperations\OneTimeOperation;

return new class extends OneTimeOperation
{
    /**
     * Determine if the operation is being processed asynchronously.
     */
    protected bool $async = true;

    /**
     * The queue that the job will be dispatched to.
     */
    protected string $queue = 'default';

    /**
     * A tag name, that this operation can be filtered by.
     */
    protected ?string $tag = null;

    /**
     * Process the operation.
     */
    public function process(): void
    {
        //
    }
};
```

--------------------------------

### Laravel One-Time Operation File Structure

Source: https://github.com/timokoerber/laravel-one-time-operations/blob/main/README.md

This is a template for a one-time operation file in Laravel. It extends the `OneTimeOperation` class and allows configuration of asynchronous processing, queue, and tags. The core logic is implemented within the `process()` method.

```php
<?php
// operations/XXXX_XX_XX_XXXXXX_awesome_operation.php

use TimoKoerber\LaravelOneTimeOperations\OneTimeOperation;

return new class extends OneTimeOperation
{
    /**
     * Determine if the operation is being processed asynchronously.
     */
    protected bool $async = true;
    
    /**
     * The queue that the job will be dispatched to.
     */
    protected string $queue = 'default';
    
    /**
     * A tag name, that this operation can be filtered by.
     */
    protected ?string $tag = null;

    /**
     * Process the operation.
     */
    public function process(): void
    {
        //
    }
};

```

--------------------------------

### Process All Pending Operations (Bash)

Source: https://context7.com/timokoerber/laravel-one-time-operations/llms.txt

Command to execute all unprocessed one-time operations in chronological order using the Artisan CLI. Operations are dispatched as jobs and recorded to prevent re-execution. The output shows the status of each processed operation.

```bash
# Process all pending operations
php artisan operations:process

# Output:
# Processing operations.
# 2024_01_15_143052_update_user_statuses ................. DONE
# 2024_01_15_150000_migrate_user_data .................... DONE
# Processing finished.

```

--------------------------------

### Create One-Time Operation File in Laravel

Source: https://github.com/timokoerber/laravel-one-time-operations/blob/main/README.md

Generates a new one-time operation file using the artisan command. The file includes default properties like `$async`, `$queue`, and `$tag`, along with a `process()` method for custom logic. The operation is processed asynchronously by default.

```shell
php artisan operations:make AwesomeOperation
```

--------------------------------

### Create New One-Time Operation File

Source: https://context7.com/timokoerber/laravel-one-time-operations/llms.txt

Generates a new one-time operation file using the `operations:make` Artisan command. This command creates a timestamped file in the configured operations directory, containing a class that extends `OneTimeOperation`.

```bash
# Create a standard operation file
php artisan operations:make UpdateUserStatuses

# Output: One-time operation [2024_01_15_143052_update_user_statuses] created successfully.

# Alternative alias
php artisan make:operation UpdateUserStatuses

# Create a minimal operation file without extra attributes
php artisan operations:make UpdateUserStatuses --essential
php artisan operations:make UpdateUserStatuses -e
```

--------------------------------

### Re-run a Specific Operation using Shell

Source: https://github.com/timokoerber/laravel-one-time-operations/blob/main/README.md

An operation can be re-run manually by providing its name as an argument to the `operations:process` Artisan command. This is useful for retrying operations that may have failed or for re-executing them intentionally.

```shell
php artisan operations:process XXXX_XX_XX_XXXXXX_awesome_operation
```

--------------------------------

### Configure Laravel One-Time Operations

Source: https://context7.com/timokoerber/laravel-one-time-operations/llms.txt

Defines configuration settings for the one-time operations package. This includes specifying the directory for operation files, the database table name, and the database connection, which is useful for multi-tenancy.

```php
<?php

return [
    'directory' => 'operations',
    'table' => 'operations',
    'connection' => null,
];
```

--------------------------------

### Tag Filtering for Operations (Bash)

Source: https://context7.com/timokoerber/laravel-one-time-operations/llms.txt

Commands to process only operations that have specific tags assigned. This is useful for orchestrating operations, such as running certain tasks before or after database migrations. Multiple tags can be specified.

```bash
# Process only operations tagged 'before-migrations'
php artisan operations:process --tag=before-migrations

# Process operations with multiple tags
php artisan operations:process --tag=critical --tag=user-data

```

--------------------------------

### Force Asynchronous or Synchronous Processing in Laravel

Source: https://github.com/timokoerber/laravel-one-time-operations/blob/main/README.md

Allows forcing the execution mode of one-time operations during processing. Use `--async` to force asynchronous dispatching (using `dispatch()`) or `--sync` to force synchronous execution (using `dispatchSync()`), overriding the `$async` attribute in the operation file.

```shell
php artisan operations:process --async  // force dispatch()
php artisan operations:process --sync   // force dispatchSync()
```

--------------------------------

### Process All One-Time Operations in Laravel

Source: https://github.com/timokoerber/laravel-one-time-operations/blob/main/README.md

Executes all pending one-time operation files. Processed operations are recorded in the `operations` table and will not be processed again. This command is typically part of the deployment process.

```shell
php artisan operations:process
```

--------------------------------

### Isolated Execution of Laravel Operations on Multi-Server

Source: https://github.com/timokoerber/laravel-one-time-operations/blob/main/README.md

Ensures that the `operations:process` command runs as a single instance across multiple servers when using a Multi-Server Architecture. This is achieved by utilizing the `--isolated` option, leveraging Laravel's Isolatable Commands feature.

```shell
php artisan operations:process --isolated
```

--------------------------------

### Re-run Specific Operation (Bash)

Source: https://context7.com/timokoerber/laravel-one-time-operations/llms.txt

Command to re-process a specific one-time operation using its filename. This is useful for fixing failed operations or re-running them after code changes. The user is prompted to confirm re-execution.

```bash
# Re-run a specific operation
php artisan operations:process 2024_01_15_143052_update_user_statuses

# Output:
# Operation was processed before. Process it again? (yes/no) [no]: yes
# Processing operation 2024_01_15_143052_update_user_statuses.
# 2024_01_15_143052_update_user_statuses ................. DONE
# Processing finished.

```

--------------------------------

### Show One-Time Operations Status

Source: https://github.com/timokoerber/laravel-one-time-operations/blob/main/README.md

Displays the status of one-time operations. Allows filtering to show all, pending, processed, or disposed operations, and supports combining multiple filters.

```shell
php artisan operations:show
php artisan operations:show pending
php artisan operations:show processed
php artisan operations:show disposed
php artisan operations:show pending processed disposed
```

--------------------------------

### Filter Operations by Tag using PHP and Shell

Source: https://github.com/timokoerber/laravel-one-time-operations/blob/main/README.md

Operations can be tagged in their PHP definition and then filtered during processing using the `--tag` option in the Artisan command. This allows for selective execution of operations, useful for staged deployments or specific tasks.

```php
<?php
// operations/XXXX_XX_XX_XXXXXX_awesome_operation.php

    protected ?string $tag = "awesome";
};
```

```shell
php artisan operations:process --tag=awesome  // run only operations with "awesome" tag
```

```shell
php artisan operations:process --tag=awesome --tag=foobar // run only operations with "awesome" or "foobar" tag
```

--------------------------------

### Test Mode Operation Processing (Bash)

Source: https://context7.com/timokoerber/laravel-one-time-operations/llms.txt

Command to run operations in test mode. This allows for repeated testing during development without marking operations as processed in the database. The output indicates that test mode is active.

```bash
# Test mode - operations won't be flagged as processed
php artisan operations:process --test

# Output:
# Testmode! Operation won't be tagged as `processed`
# Processing operations.
# 2024_01_15_143052_update_user_statuses ................. DONE
# Processing finished.

```

--------------------------------

### Filter Operations by Status (Bash)

Source: https://context7.com/timokoerber/laravel-one-time-operations/llms.txt

Commands to filter the list of operations displayed by the `operations:show` command based on their status. You can view only pending, processed, or disposed operations, or a combination thereof.

```bash
# Filter by status
php artisan operations:show pending
php artisan operations:show processed
php artisan operations:show disposed

# Multiple filters
php artisan operations:show pending processed

```

--------------------------------

### Isolated Operation Execution (Bash)

Source: https://context7.com/timokoerber/laravel-one-time-operations/llms.txt

Command to ensure that only one instance of the operation processor runs across multiple servers in a deployment. It utilizes Laravel's atomic locks to prevent concurrent execution and maintain data integrity.

```bash
# Run isolated (only one instance across all servers)
php artisan operations:process --isolated

```

--------------------------------

### Force Specific Queue for Laravel Operations

Source: https://github.com/timokoerber/laravel-one-time-operations/blob/main/README.md

Enables specifying a queue for all one-time operations processed via the artisan command using the `--queue` option. This overrides the `$queue` attribute defined within individual operation files.

```shell
php artisan operations:process --queue=redis  // force redis queue
```

--------------------------------

### Custom Queue Assignment (Bash)

Source: https://context7.com/timokoerber/laravel-one-time-operations/llms.txt

Command to dispatch all operations to a specific queue, overriding the `$queue` property defined within the operation class. This allows for centralized management of operation processing across different queues.

```bash
# Dispatch all operations to the 'redis' queue
php artisan operations:process --queue=redis

# Dispatch to high-priority queue
php artisan operations:process --queue=high-priority

```

--------------------------------

### Query and Manage Operation Records with Eloquent Model

Source: https://context7.com/timokoerber/laravel-one-time-operations/llms.txt

The `Operation` Eloquent model allows you to interact with the database to track and query processed operations. You can find specific operations by name, inspect their details like dispatch method and processed time, retrieve all processed operations, or check if an operation has already been processed. It also supports manually storing operation records.

```php
<?php

use TimoKoerber\LaravelOneTimeOperations\Models\Operation;

// Find a specific operation
$operation = Operation::whereName('2024_01_15_143052_update_user_statuses')->first();

// Check operation details
echo $operation->name;          // '2024_01_15_143052_update_user_statuses'
echo $operation->dispatched;    // 'async' or 'sync'
echo $operation->processed_at;  // Carbon datetime instance
echo $operation->file_path;     // Full path to operation file

// Get all processed operations
$processedOperations = Operation::all();

// Check if operation exists (was processed)
$wasProcessed = Operation::whereName('2024_01_15_143052_update_user_statuses')->exists();

// Manually store an operation (used internally)
Operation::storeOperation('custom_operation_name', async: true);
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.