20694090575

Committed 04 Jan 2026 02:06PM UTC coverage: 68.615% (+4.5%) from 64.117%

Build # 20694090575

Build Type

Pull #236

github

Committed by

web-flow

Commit Message

Merge 367783af4 into f6c84deae

Pull Request Pull Request #236: Discount Rules

Run Details

260 of 319 new or added lines in 19 files covered. (81.5%)

105 existing lines in 40 files now uncovered.

1679 of 2447 relevant lines covered (68.61%)

25.06 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

85.92

/src/Resources/DiscountRuleResource.php

<?php

declare(strict_types=1);

namespace Cone\Bazar\Resources;

use Cone\Bazar\Bazar;
use Cone\Bazar\Enums\DiscountRuleValueType;
use Cone\Bazar\Enums\DiscountType;
use Cone\Bazar\Interfaces\Buyable;
use Cone\Bazar\Models\DiscountRule;
use Cone\Bazar\Models\Product;
use Cone\Bazar\Models\Variant;
use Cone\Root\Fields\BelongsToMany;
use Cone\Root\Fields\Boolean;
use Cone\Root\Fields\ID;
use Cone\Root\Fields\MorphToMany;
use Cone\Root\Fields\Number;
use Cone\Root\Fields\Repeater;
use Cone\Root\Fields\Select;
use Cone\Root\Fields\Text;
use Cone\Root\Resources\Resource;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Http\Request;
use Illuminate\Support\Str;
use Illuminate\Validation\Rule;

class DiscountRuleResource extends Resource
{
    /**
     * The model class.
     *
     * @var class-string<\Cone\Bazar\Models\DiscountRule>
     */
    protected string $model = DiscountRule::class;

    /**
     * The group for the resource.
     */
    protected string $group = 'Shop';

    /**
     * Get the model for the resource.
     */
    public function getModel(): string
    {
        return $this->model::getProxiedClass();
    }

    /**
     * {@inheritdoc}
     */
    public function modelTitle(Model $model): string
    {
        return $model->name ?: parent::modelTitle($model);
    }

    /**
     * Define the fields.
     */
    public function fields(Request $request): array
    {
        return [
            ID::make(),

            Text::make(__('Name'), 'name')
                ->sortable()
                ->searchable()
                ->hydratesOnChange()
                ->rules(['required', 'string', 'max:255']),

            Boolean::make(__('Active'), 'active')
                ->sortable()
                ->rules(['boolean']),

            Boolean::make(__('Stackable'), 'stackable')
                ->sortable()
                ->rules(['boolean']),

            BelongsToMany::make(__('Users'), 'users')
                ->searchable(columns: ['name', 'email'])
                ->async()
                ->display('name'),

            Select::make(__('Discountable Type'), 'discountable_type')
                ->options(array_combine(
                    DiscountRule::getDiscountableTypes(),
                    array_map(static function (string $type): string {
                        return __(Str::of($type)->classBasename()->value());
                    }, DiscountRule::getDiscountableTypes()),
                ))
                ->sortable()
                ->rules(['required', 'string'])
                ->hydratesOnChange(),

            MorphToMany::make(__('Discountables'), 'discountables')
                ->hiddenOn(['index'])
                ->withRelatableQuery(static function (Request $request, Builder $query, Model $model): Builder {
                    return match (true) {
                        $query->getModel() instanceof Product,
                        $query->getModel() instanceof Variant => $query,
                        default => $query->whereRaw('1 = 0'),
                    };
                })
                ->display(static function (Model $model): string {
                    return match (true) {
                        $model instanceof Buyable => sprintf('#%s - %s', (string) $model->getKey(), $model->getBuyableName()),
                        default => (string) $model->getKey(),
                    };
                }),

            Select::make(__('Value Type'), 'value_type')
                ->options(DiscountRuleValueType::toArray())
                ->sortable()
                ->rules(['required', 'string', Rule::in(array_column(DiscountRuleValueType::cases(), 'value'))]),

            Repeater::make(__('Rules'), 'rules')
                ->withFields(static function (): array {
                    return [
                        Number::make(__('Value'), 'value')
                            ->required()
                            ->rules(['required', 'numeric', 'min:0']),

                        Select::make(__('Type'), 'type')
                            ->options(DiscountType::toArray())
                            ->required()
                            ->rules(['required', Rule::in(array_column(DiscountType::cases(), 'value'))]),

                        Number::make(__('Discount'), 'discount')
                            ->required()
                            ->rules(['required', 'numeric', 'min:0']),

                        Select::make(__('Currency'), 'currency')
                            ->nullable()
                            ->options(array_column(Bazar::getCurrencies(), 'name', 'value'))
                            ->format(static function (Request $request, Model $model, ?string $value): string {
                                return (string) ($value ?: '*');
                            }),
                    ];
                }),
        ];
    }
}

1	<?php
2
3	declare(strict_types=1);
4
5	namespace Cone\Bazar\Resources;
6
7	use Cone\Bazar\Bazar;
8	use Cone\Bazar\Enums\DiscountRuleValueType;
9	use Cone\Bazar\Enums\DiscountType;
10	use Cone\Bazar\Interfaces\Buyable;
11	use Cone\Bazar\Models\DiscountRule;
12	use Cone\Bazar\Models\Product;
13	use Cone\Bazar\Models\Variant;
14	use Cone\Root\Fields\BelongsToMany;
15	use Cone\Root\Fields\Boolean;
16	use Cone\Root\Fields\ID;
17	use Cone\Root\Fields\MorphToMany;
18	use Cone\Root\Fields\Number;
19	use Cone\Root\Fields\Repeater;
20	use Cone\Root\Fields\Select;
21	use Cone\Root\Fields\Text;
22	use Cone\Root\Resources\Resource;
23	use Illuminate\Database\Eloquent\Builder;
24	use Illuminate\Database\Eloquent\Model;
25	use Illuminate\Http\Request;
26	use Illuminate\Support\Str;
27	use Illuminate\Validation\Rule;
28
29	class DiscountRuleResource extends Resource
30	{
31	/**
32	* The model class.
33	*
34	* @var class-string<\Cone\Bazar\Models\DiscountRule>
35	*/
36	protected string $model = DiscountRule::class;
37
38	/**
39	* The group for the resource.
40	*/
41	protected string $group = 'Shop';
42
43	/**
44	* Get the model for the resource.
45	*/
46	public function getModel(): string	101✔
47	{
48	return $this->model::getProxiedClass();	101✔
49	}
50
51	/**
52	* {@inheritdoc}
53	*/
NEW 54	public function modelTitle(Model $model): string	×
55	{
NEW 56	return $model->name ?: parent::modelTitle($model);	×
57	}
58
59	/**
60	* Define the fields.
61	*/
62	public function fields(Request $request): array	101✔
63	{
64	return [	101✔
65	ID::make(),	101✔
66
67	Text::make(__('Name'), 'name')	101✔
68	->sortable()	101✔
69	->searchable()	101✔
70	->hydratesOnChange()	101✔
71	->rules(['required', 'string', 'max:255']),	101✔
72
73	Boolean::make(__('Active'), 'active')	101✔
74	->sortable()	101✔
75	->rules(['boolean']),	101✔
76
77	Boolean::make(__('Stackable'), 'stackable')	101✔
78	->sortable()	101✔
79	->rules(['boolean']),	101✔
80
81	BelongsToMany::make(__('Users'), 'users')	101✔
82	->searchable(columns: ['name', 'email'])	101✔
83	->async()	101✔
84	->display('name'),	101✔
85
86	Select::make(__('Discountable Type'), 'discountable_type')	101✔
87	->options(array_combine(	101✔
88	DiscountRule::getDiscountableTypes(),	101✔
89	array_map(static function (string $type): string {	101✔
90	return __(Str::of($type)->classBasename()->value());	101✔
91	}, DiscountRule::getDiscountableTypes()),	101✔
92	))	101✔
93	->sortable()	101✔
94	->rules(['required', 'string'])	101✔
95	->hydratesOnChange(),	101✔
96
97	MorphToMany::make(__('Discountables'), 'discountables')	101✔
98	->hiddenOn(['index'])	101✔
99	->withRelatableQuery(static function (Request $request, Builder $query, Model $model): Builder {	101✔
NEW 100	return match (true) {	×
NEW 101	$query->getModel() instanceof Product,	×
NEW 102	$query->getModel() instanceof Variant => $query,	×
NEW 103	default => $query->whereRaw('1 = 0'),	×
NEW 104	};	×
105	})	101✔
106	->display(static function (Model $model): string {	101✔
107	return match (true) {
NEW 108	$model instanceof Buyable => sprintf('#%s - %s', (string) $model->getKey(), $model->getBuyableName()),	×
NEW 109	default => (string) $model->getKey(),	×
110	};
111	}),	101✔
112
113	Select::make(__('Value Type'), 'value_type')	101✔
114	->options(DiscountRuleValueType::toArray())	101✔
115	->sortable()	101✔
116	->rules(['required', 'string', Rule::in(array_column(DiscountRuleValueType::cases(), 'value'))]),	101✔
117
118	Repeater::make(__('Rules'), 'rules')	101✔
119	->withFields(static function (): array {	101✔
120	return [	101✔
121	Number::make(__('Value'), 'value')	101✔
122	->required()	101✔
123	->rules(['required', 'numeric', 'min:0']),	101✔
124
125	Select::make(__('Type'), 'type')	101✔
126	->options(DiscountType::toArray())	101✔
127	->required()	101✔
128	->rules(['required', Rule::in(array_column(DiscountType::cases(), 'value'))]),	101✔
129
130	Number::make(__('Discount'), 'discount')	101✔
131	->required()	101✔
132	->rules(['required', 'numeric', 'min:0']),	101✔
133
134	Select::make(__('Currency'), 'currency')	101✔
135	->nullable()	101✔
136	->options(array_column(Bazar::getCurrencies(), 'name', 'value'))	101✔
137	->format(static function (Request $request, Model $model, ?string $value): string {	101✔
NEW 138	return (string) ($value ?: '*');	×
139	}),	101✔
140	];	101✔
141	}),	101✔
142	];	101✔
143	}
144	}

conedevelopment / bazar / 20694090575

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous