[增添]添加了datasource的setting数据库以及默认值

vendor/filament/actions/docs/07-prebuilt-actions/01-create.md

@@ -0,0 +1,247 @@
+---
+title: Create action
+---
+
+## Overview
+
+Filament includes a prebuilt action that is able to create Eloquent records. When the trigger button is clicked, a modal will open with a form inside. The user fills the form, and that data is validated and saved into the database. You may use it like so:
+
+```php
+use Filament\Actions\CreateAction;
+use Filament\Forms\Components\TextInput;
+
+CreateAction::make()
+    ->model(Post::class)
+    ->form([
+        TextInput::make('title')
+            ->required()
+            ->maxLength(255),
+        // ...
+    ])
+```
+
+If you want to add this action to the header of a table instead, you can use `Filament\Tables\Actions\CreateAction`:
+
+```php
+use Filament\Forms\Components\TextInput;
+use Filament\Tables\Actions\CreateAction;
+use Filament\Tables\Table;
+
+public function table(Table $table): Table
+{
+    return $table
+        ->headerActions([
+            CreateAction::make()
+                ->form([
+                    TextInput::make('title')
+                        ->required()
+                        ->maxLength(255),
+                    // ...
+                ]),
+        ]);
+}
+```
+
+## Customizing data before saving
+
+Sometimes, you may wish to modify form data before it is finally saved to the database. To do this, you may use the `mutateFormDataUsing()` method, which has access to the `$data` as an array, and returns the modified version:
+
+```php
+CreateAction::make()
+    ->mutateFormDataUsing(function (array $data): array {
+        $data['user_id'] = auth()->id();
+
+        return $data;
+    })
+```
+
+## Customizing the creation process
+
+You can tweak how the record is created with the `using()` method:
+
+```php
+use Illuminate\Database\Eloquent\Model;
+
+CreateAction::make()
+    ->using(function (array $data, string $model): Model {
+        return $model::create($data);
+    })
+```
+
+`$model` is the class name of the model, but you can replace this with your own hard-coded class if you wish.
+
+## Redirecting after creation
+
+You may set up a custom redirect when the form is submitted using the `successRedirectUrl()` method:
+
+```php
+CreateAction::make()
+    ->successRedirectUrl(route('posts.list'))
+```
+
+If you want to redirect using the created record, use the `$record` parameter:
+
+```php
+use Illuminate\Database\Eloquent\Model;
+
+CreateAction::make()
+    ->successRedirectUrl(fn (Model $record): string => route('posts.edit', [
+        'post' => $record,
+    ]))
+```
+
+## Customizing the save notification
+
+When the record is successfully created, a notification is dispatched to the user, which indicates the success of their action.
+
+To customize the title of this notification, use the `successNotificationTitle()` method:
+
+```php
+CreateAction::make()
+    ->successNotificationTitle('User registered')
+```
+
+You may customize the entire notification using the `successNotification()` method:
+
+```php
+use Filament\Notifications\Notification;
+
+CreateAction::make()
+    ->successNotification(
+       Notification::make()
+            ->success()
+            ->title('User registered')
+            ->body('The user has been created successfully.'),
+    )
+```
+
+To disable the notification altogether, use the `successNotification(null)` method:
+
+```php
+CreateAction::make()
+    ->successNotification(null)
+```
+
+## Lifecycle hooks
+
+Hooks may be used to execute code at various points within the action's lifecycle, like before a form is saved.
+
+There are several available hooks:
+
+```php
+CreateAction::make()
+    ->beforeFormFilled(function () {
+        // Runs before the form fields are populated with their default values.
+    })
+    ->afterFormFilled(function () {
+        // Runs after the form fields are populated with their default values.
+    })
+    ->beforeFormValidated(function () {
+        // Runs before the form fields are validated when the form is submitted.
+    })
+    ->afterFormValidated(function () {
+        // Runs after the form fields are validated when the form is submitted.
+    })
+    ->before(function () {
+        // Runs before the form fields are saved to the database.
+    })
+    ->after(function () {
+        // Runs after the form fields are saved to the database.
+    })
+```
+
+## Halting the creation process
+
+At any time, you may call `$action->halt()` from inside a lifecycle hook or mutation method, which will halt the entire creation process:
+
+```php
+use App\Models\Post;
+use Filament\Notifications\Actions\Action;
+use Filament\Notifications\Notification;
+
+CreateAction::make()
+    ->before(function (CreateAction $action, Post $record) {
+        if (! $record->team->subscribed()) {
+            Notification::make()
+                ->warning()
+                ->title('You don\'t have an active subscription!')
+                ->body('Choose a plan to continue.')
+                ->persistent()
+                ->actions([
+                    Action::make('subscribe')
+                        ->button()
+                        ->url(route('subscribe'), shouldOpenInNewTab: true),
+                ])
+                ->send();
+        
+            $action->halt();
+        }
+    })
+```
+
+If you'd like the action modal to close too, you can completely `cancel()` the action instead of halting it:
+
+```php
+$action->cancel();
+```
+
+## Using a wizard
+
+You may easily transform the creation process into a multistep wizard. Instead of using a `form()`, define a `steps()` array and pass your `Step` objects:
+
+```php
+use Filament\Forms\Components\MarkdownEditor;
+use Filament\Forms\Components\TextInput;
+use Filament\Forms\Components\Toggle;
+use Filament\Forms\Components\Wizard\Step;
+
+CreateAction::make()
+    ->steps([
+        Step::make('Name')
+            ->description('Give the category a unique name')
+            ->schema([
+                TextInput::make('name')
+                    ->required()
+                    ->live()
+                    ->afterStateUpdated(fn ($state, callable $set) => $set('slug', Str::slug($state))),
+                TextInput::make('slug')
+                    ->disabled()
+                    ->required()
+                    ->unique(Category::class, 'slug'),
+            ])
+            ->columns(2),
+        Step::make('Description')
+            ->description('Add some extra details')
+            ->schema([
+                MarkdownEditor::make('description'),
+            ]),
+        Step::make('Visibility')
+            ->description('Control who can view it')
+            ->schema([
+                Toggle::make('is_visible')
+                    ->label('Visible to customers.')
+                    ->default(true),
+            ]),
+    ])
+```
+
+Now, create a new record to see your wizard in action! Edit will still use the form defined within the resource class.
+
+If you'd like to allow free navigation, so all the steps are skippable, use the `skippableSteps()` method:
+
+```php
+CreateAction::make()
+    ->steps([
+        // ...
+    ])
+    ->skippableSteps()
+```
+
+## Disabling create another
+
+If you'd like to remove the "create another" button from the modal, you can use the `createAnother(false)` method:
+
+```php
+CreateAction::make()
+    ->createAnother(false)
+```