wip adjustment statuses

app/Enums/Accounting/AdjustmentStatus.php

     case Active = 'active';
     case Upcoming = 'upcoming';
     case Expired = 'expired';
+    case Paused = 'paused';
     case Archived = 'archived';
 
     public function getLabel(): ?string
     {
         return match ($this) {
             self::Active => 'primary',
-            self::Upcoming => 'warning',
+            self::Upcoming, self::Paused => 'warning',
             self::Expired => 'danger',
             self::Archived => 'gray',
         };
     }
+
+    /**
+     * Check if the status is set manually (not calculated from dates)
+     */
+    public function isManualStatus(): bool
+    {
+        return in_array($this, [self::Paused, self::Archived]);
+    }
+
+    /**
+     * Check if the status is system-calculated based on dates
+     */
+    public function isSystemStatus(): bool
+    {
+        return in_array($this, [self::Active, self::Upcoming, self::Expired]);
+    }
 }

app/Filament/Company/Clusters/Settings/Resources/AdjustmentResource.php

 use App\Enums\Accounting\AdjustmentCategory;
 use App\Enums\Accounting\AdjustmentComputation;
 use App\Enums\Accounting\AdjustmentScope;
-use App\Enums\Accounting\AdjustmentStatus;
 use App\Enums\Accounting\AdjustmentType;
 use App\Filament\Company\Clusters\Settings;
 use App\Filament\Company\Clusters\Settings\Resources\AdjustmentResource\Pages;
 use App\Models\Accounting\Adjustment;
 use Filament\Forms;
 use Filament\Forms\Form;
+use Filament\Notifications\Notification;
 use Filament\Resources\Resource;
 use Filament\Tables;
 use Filament\Tables\Table;
+use Illuminate\Database\Eloquent\Collection;
 
 class AdjustmentResource extends Resource
 {
             ->actions([
                 Tables\Actions\ActionGroup::make([
                     Tables\Actions\EditAction::make(),
+                    Tables\Actions\Action::make('pause')
+                        ->label('Pause')
+                        ->icon('heroicon-m-pause')
+                        ->color('warning')
+                        ->form([
+                            Forms\Components\DateTimePicker::make('paused_until')
+                                ->label('Auto-resume Date')
+                                ->helperText('When should this adjustment automatically resume? Leave empty to keep paused indefinitely.')
+                                ->after('now'),
+                            Forms\Components\Textarea::make('status_reason')
+                                ->label('Reason for Pausing')
+                                ->maxLength(255),
+                        ])
+                        ->visible(fn (Adjustment $record) => $record->canBePaused())
+                        ->action(function (Adjustment $record, array $data) {
+                            $pausedUntil = $data['paused_until'] ?? null;
+                            $reason = $data['status_reason'] ?? null;
+                            $record->pause($reason, $pausedUntil);
+                        }),
+                    Tables\Actions\Action::make('resume')
+                        ->label('Resume')
+                        ->icon('heroicon-m-play')
+                        ->color('success')
+                        ->requiresConfirmation()
+                        ->visible(fn (Adjustment $record) => $record->canBeResumed())
+                        ->action(fn (Adjustment $record) => $record->resume()),
                     Tables\Actions\Action::make('archive')
                         ->label('Archive')
-                        ->icon('heroicon-o-archive-box-x-mark')
+                        ->icon('heroicon-m-archive-box')
                         ->color('danger')
-                        ->requiresConfirmation()
-                        ->visible(static fn (Adjustment $record) => $record->status !== AdjustmentStatus::Archived)
-                        ->action(fn (Adjustment $record) => $record->update(['status' => AdjustmentStatus::Archived])),
+                        ->form([
+                            Forms\Components\Textarea::make('status_reason')
+                                ->label('Reason for Archiving')
+                                ->maxLength(255),
+                        ])
+                        ->visible(fn (Adjustment $record) => $record->canBeArchived())
+                        ->action(function (Adjustment $record, array $data) {
+                            $reason = $data['status_reason'] ?? null;
+                            $record->archive($reason);
+                        }),
                 ]),
             ])
             ->bulkActions([
-                //
+                Tables\Actions\BulkActionGroup::make([
+                    Tables\Actions\BulkAction::make('pause')
+                        ->label('Pause')
+                        ->icon('heroicon-m-pause')
+                        ->color('warning')
+                        ->form([
+                            Forms\Components\DateTimePicker::make('paused_until')
+                                ->label('Auto-resume Date')
+                                ->helperText('When should these adjustments automatically resume? Leave empty to keep paused indefinitely.')
+                                ->after('now'),
+                            Forms\Components\Textarea::make('status_reason')
+                                ->label('Reason for Pausing')
+                                ->maxLength(255),
+                        ])
+                        ->databaseTransaction()
+                        ->successNotificationTitle('Adjustments paused')
+                        ->failureNotificationTitle('Failed to pause adjustments')
+                        ->before(function (Collection $records, Tables\Actions\BulkAction $action) {
+                            $isInvalid = $records->contains(fn (Adjustment $record) => ! $record->canBePaused());
+
+                            if ($isInvalid) {
+                                Notification::make()
+                                    ->title('Pause failed')
+                                    ->body('Only adjustments that are currently active can be paused. Please adjust your selection and try again.')
+                                    ->persistent()
+                                    ->danger()
+                                    ->send();
+
+                                $action->cancel(true);
+                            }
+                        })
+                        ->deselectRecordsAfterCompletion()
+                        ->action(function (Collection $records, array $data) {
+                            $pausedUntil = $data['paused_until'] ?? null;
+                            $reason = $data['status_reason'] ?? null;
+
+                            $records->each(function (Adjustment $record) use ($reason, $pausedUntil) {
+                                $record->pause($reason, $pausedUntil);
+                            });
+                        }),
+                    Tables\Actions\BulkAction::make('resume')
+                        ->label('Resume')
+                        ->icon('heroicon-m-play')
+                        ->color('success')
+                        ->databaseTransaction()
+                        ->successNotificationTitle('Adjustments resumed')
+                        ->failureNotificationTitle('Failed to resume adjustments')
+                        ->before(function (Collection $records, Tables\Actions\BulkAction $action) {
+                            $isInvalid = $records->contains(fn (Adjustment $record) => ! $record->canBeResumed());
+
+                            if ($isInvalid) {
+                                Notification::make()
+                                    ->title('Resume failed')
+                                    ->body('Only adjustments that are currently paused can be resumed. Please adjust your selection and try again.')
+                                    ->persistent()
+                                    ->danger()
+                                    ->send();
+
+                                $action->cancel(true);
+                            }
+                        })
+                        ->deselectRecordsAfterCompletion()
+                        ->action(function (Collection $records) {
+                            $records->each(function (Adjustment $record) {
+                                $record->resume();
+                            });
+                        }),
+                    Tables\Actions\BulkAction::make('archive')
+                        ->label('Archive')
+                        ->icon('heroicon-m-archive-box')
+                        ->color('danger')
+                        ->form([
+                            Forms\Components\Textarea::make('status_reason')
+                                ->label('Reason for Archiving')
+                                ->maxLength(255),
+                        ])
+                        ->databaseTransaction()
+                        ->successNotificationTitle('Adjustments archived')
+                        ->failureNotificationTitle('Failed to archive adjustments')
+                        ->before(function (Collection $records, Tables\Actions\BulkAction $action) {
+                            $isInvalid = $records->contains(fn (Adjustment $record) => ! $record->canBeArchived());
+
+                            if ($isInvalid) {
+                                Notification::make()
+                                    ->title('Archive failed')
+                                    ->body('Only adjustments that are currently active or paused can be archived. Please adjust your selection and try again.')
+                                    ->persistent()
+                                    ->danger()
+                                    ->send();
+
+                                $action->cancel(true);
+                            }
+                        })
+                        ->deselectRecordsAfterCompletion()
+                        ->action(function (Collection $records, array $data) {
+                            $reason = $data['status_reason'] ?? null;
+
+                            $records->each(function (Adjustment $record) use ($reason) {
+                                $record->archive($reason);
+                            });
+                        }),
+                ]),
             ]);
     }
 

app/Models/Accounting/Adjustment.php

         'account_id',
         'name',
         'status',
+        'status_reason',
         'description',
         'category',
         'type',
         'scope',
         'start_date',
         'end_date',
+        'paused_at',
+        'paused_until',
+        'archived_at',
         'created_by',
         'updated_by',
     ];
         'scope' => AdjustmentScope::class,
         'start_date' => 'datetime',
         'end_date' => 'datetime',
+        'paused_at' => 'datetime',
+        'paused_until' => 'datetime',
+        'archived_at' => 'datetime',
     ];
 
     public function account(): BelongsTo
         return $this->category->isDiscount() && $this->type->isPurchase();
     }
 
-    public function calculateStatus(): AdjustmentStatus
+    // Add these methods to your Adjustment model
+
+    /**
+     * Check if adjustment can be paused
+     */
+    public function canBePaused(): bool
     {
-        if ($this->status === AdjustmentStatus::Archived) {
-            return AdjustmentStatus::Archived;
-        }
+        return $this->status === AdjustmentStatus::Active;
+    }
+
+    /**
+     * Check if adjustment can be resumed
+     */
+    public function canBeResumed(): bool
+    {
+        return $this->status === AdjustmentStatus::Paused;
+    }
 
+    /**
+     * Check if adjustment can be archived
+     */
+    public function canBeArchived(): bool
+    {
+        return $this->status !== AdjustmentStatus::Archived;
+    }
+
+    /**
+     * Calculate the natural status of the adjustment based on dates
+     */
+    public function calculateNaturalStatus(): AdjustmentStatus
+    {
         if ($this->start_date?->isFuture()) {
             return AdjustmentStatus::Upcoming;
         }
         return AdjustmentStatus::Active;
     }
 
+    /**
+     * Pause the adjustment
+     */
+    public function pause(?string $reason = null, ?\DateTime $untilDate = null): bool
+    {
+        if (! $this->canBePaused()) {
+            return false;
+        }
+
+        $this->paused_at = now();
+        $this->paused_until = $untilDate;
+        $this->status = AdjustmentStatus::Paused;
+        $this->status_reason = $reason;
+
+        return $this->save();
+    }
+
+    /**
+     * Resume the adjustment
+     */
+    public function resume(): bool
+    {
+        if (! $this->canBeResumed()) {
+            return false;
+        }
+
+        $this->paused_at = null;
+        $this->paused_until = null;
+        $this->status_reason = null;
+        $this->status = $this->calculateNaturalStatus();
+
+        return $this->save();
+    }
+
+    /**
+     * Archive the adjustment
+     */
+    public function archive(?string $reason = null): bool
+    {
+        if (! $this->canBeArchived()) {
+            return false;
+        }
+
+        $this->status = AdjustmentStatus::Archived;
+        $this->status_reason = $reason;
+
+        return $this->save();
+    }
+
+    /**
+     * Check if the adjustment should be automatically resumed
+     */
+    public function shouldAutoResume(): bool
+    {
+        return $this->status === AdjustmentStatus::Paused &&
+            $this->paused_until !== null &&
+            $this->paused_until->isPast();
+    }
+
+    /**
+     * Refresh the status based on current dates and conditions
+     */
+    public function refreshStatus(): bool
+    {
+        // Don't automatically change archived or paused status
+        if ($this->status === AdjustmentStatus::Archived ||
+            ($this->status === AdjustmentStatus::Paused && ! $this->shouldAutoResume())) {
+            return false;
+        }
+
+        // Check if a paused adjustment should be auto-resumed
+        if ($this->shouldAutoResume()) {
+            return $this->resume();
+        }
+
+        // Calculate natural status based on dates
+        $naturalStatus = $this->calculateNaturalStatus();
+
+        // Only update if the status would change
+        if ($this->status !== $naturalStatus) {
+            $this->status = $naturalStatus;
+
+            return $this->save();
+        }
+
+        return false;
+    }
+
     protected static function newFactory(): Factory
     {
         return AdjustmentFactory::new();

app/Observers/AdjustmentObserver.php

                 $adjustment->account()->associate($account);
             }
         }
-
-        if ($adjustment->status !== AdjustmentStatus::Archived) {
-            $adjustment->status = $adjustment->calculateStatus();
-        }
     }
 
     public function updating(Adjustment $adjustment): void
                 'description' => $adjustment->description,
             ]);
         }
+    }
+
+    /**
+     * Handle the Adjustment "saving" event.
+     */
+    public function saving(Adjustment $adjustment): void
+    {
+        // Handle dates changes affecting status
+        // Only if the status isn't being explicitly changed and not in a manual state
+        if ($adjustment->isDirty(['start_date', 'end_date']) &&
+            ! $adjustment->isDirty('status') &&
+            ! in_array($adjustment->status, [AdjustmentStatus::Archived, AdjustmentStatus::Paused])) {
+
+            $adjustment->status = $adjustment->calculateNaturalStatus();
+        }
+
+        // Handle auto-resume for paused adjustments with a paused_until date
+        if ($adjustment->shouldAutoResume() && ! $adjustment->isDirty('status')) {
+            $adjustment->status = $adjustment->calculateNaturalStatus();
+            $adjustment->paused_at = null;
+            $adjustment->paused_until = null;
+            $adjustment->status_reason = null;
+        }
 
-        if ($adjustment->status !== AdjustmentStatus::Archived) {
-            $adjustment->status = $adjustment->calculateStatus();
+        // Ensure consistency between paused status and paused_at field
+        if ($adjustment->status === AdjustmentStatus::Paused && ! $adjustment->paused_at) {
+            $adjustment->paused_at = now();
         }
     }
 }

database/migrations/2024_11_14_230753_create_adjustments_table.php

             $table->foreignId('account_id')->nullable()->constrained('accounts')->nullOnDelete();
             $table->string('name')->nullable();
             $table->string('status')->default('active');
+            $table->text('status_reason')->nullable();
             $table->text('description')->nullable();
             $table->string('category')->default('tax');
             $table->string('type')->default('sales');
             $table->string('scope')->nullable();
             $table->dateTime('start_date')->nullable();
             $table->dateTime('end_date')->nullable();
+            $table->timestamp('paused_at')->nullable();
+            $table->timestamp('paused_until')->nullable();
+            $table->timestamp('archived_at')->nullable();
             $table->foreignId('created_by')->nullable()->constrained('users')->nullOnDelete();
             $table->foreignId('updated_by')->nullable()->constrained('users')->nullOnDelete();
             $table->timestamps();