20693245827

Committed 04 Jan 2026 12:57PM UTC coverage: 66.667% (+2.6%) from 64.117%

Build # 20693245827

Build Type

Pull #236

github

Committed by

web-flow

Commit Message

Merge 790b9166d into f6c84deae

Pull Request Pull Request #236: Discount Rules

Run Details

212 of 311 new or added lines in 18 files covered. (68.17%)

105 existing lines in 40 files now uncovered.

1626 of 2439 relevant lines covered (66.67%)

18.59 hits per line

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

85.71

/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')
                ->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	70✔
47	{
48	return $this->model::getProxiedClass();	70✔
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	70✔
63	{
64	return [	70✔
65	ID::make(),	70✔
66
67	Text::make(__('Name'), 'name')	70✔
68	->sortable()	70✔
69	->searchable()	70✔
70	->hydratesOnChange()	70✔
71	->rules(['required', 'string', 'max:255']),	70✔
72
73	Boolean::make(__('Active'), 'active')	70✔
74	->sortable()	70✔
75	->rules(['boolean']),	70✔
76
77	Boolean::make(__('Stackable'), 'stackable')	70✔
78	->sortable()	70✔
79	->rules(['boolean']),	70✔
80
81	BelongsToMany::make(__('Users'), 'users')	70✔
82	->searchable(columns: ['name', 'email'])	70✔
83	->async()	70✔
84	->display('name'),	70✔
85
86	Select::make(__('Discountable Type'), 'discountable_type')	70✔
87	->options(array_combine(	70✔
88	DiscountRule::getDiscountableTypes(),	70✔
89	array_map(static function (string $type): string {	70✔
90	return __(Str::of($type)->classBasename()->value());	70✔
91	}, DiscountRule::getDiscountableTypes()),	70✔
92	))	70✔
93	->sortable()	70✔
94	->rules(['required', 'string'])	70✔
95	->hydratesOnChange(),	70✔
96
97	MorphToMany::make(__('Discountables'), 'discountables')	70✔
98	->withRelatableQuery(static function (Request $request, Builder $query, Model $model): Builder {	70✔
NEW 99	return match (true) {	×
NEW 100	$query->getModel() instanceof Product,	×
NEW 101	$query->getModel() instanceof Variant => $query,	×
NEW 102	default => $query->whereRaw('1 = 0'),	×
NEW 103	};	×
104	})	70✔
105	->display(static function (Model $model): string {	70✔
106	return match (true) {
NEW 107	$model instanceof Buyable => sprintf('#%s - %s', (string) $model->getKey(), $model->getBuyableName()),	×
NEW 108	default => (string) $model->getKey(),	×
109	};
110	}),	70✔
111
112	Select::make(__('Value Type'), 'value_type')	70✔
113	->options(DiscountRuleValueType::toArray())	70✔
114	->sortable()	70✔
115	->rules(['required', 'string', Rule::in(array_column(DiscountRuleValueType::cases(), 'value'))]),	70✔
116
117	Repeater::make(__('Rules'), 'rules')	70✔
118	->withFields(static function (): array {	70✔
119	return [	70✔
120	Number::make(__('Value'), 'value')	70✔
121	->required()	70✔
122	->rules(['required', 'numeric', 'min:0']),	70✔
123
124	Select::make(__('Type'), 'type')	70✔
125	->options(DiscountType::toArray())	70✔
126	->required()	70✔
127	->rules(['required', Rule::in(array_column(DiscountType::cases(), 'value'))]),	70✔
128
129	Number::make(__('Discount'), 'discount')	70✔
130	->required()	70✔
131	->rules(['required', 'numeric', 'min:0']),	70✔
132
133	Select::make(__('Currency'), 'currency')	70✔
134	->nullable()	70✔
135	->options(array_column(Bazar::getCurrencies(), 'name', 'value'))	70✔
136	->format(static function (Request $request, Model $model, ?string $value): string {	70✔
NEW 137	return (string) ($value ?: '*');	×
138	}),	70✔
139	];	70✔
140	}),	70✔
141	];	70✔
142	}
143	}

conedevelopment / bazar / 20693245827

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