@fleetbase/registry-bridge-engine 0.0.1

package/server/src/Http/Controllers/Internal/v1/RegistryExtensionBundleController.php

@@ -0,0 +1,112 @@
+<?php
+
+namespace Fleetbase\RegistryBridge\Http\Controllers\Internal\v1;
+
+use Fleetbase\Exceptions\FleetbaseRequestValidationException;
+use Fleetbase\Models\File;
+use Fleetbase\RegistryBridge\Http\Controllers\RegistryBridgeController;
+use Fleetbase\RegistryBridge\Http\Requests\CreateRegistryExtensionBundleRequest;
+use Fleetbase\RegistryBridge\Http\Requests\RegistryExtensionActionRequest;
+use Fleetbase\RegistryBridge\Models\RegistryExtensionBundle;
+use Fleetbase\Support\Utils;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Storage;
+use Illuminate\Support\Facades\Validator;
+
+class RegistryExtensionBundleController extends RegistryBridgeController
+{
+    /**
+     * The resource to query.
+     *
+     * @var string
+     */
+    public $resource = 'registry_extension_bundle';
+
+    /**
+     * Creates a record with request payload.
+     *
+     * @return \Illuminate\Http\Response
+     */
+    public function createRecord(Request $request)
+    {
+        $extensionId = $request->input('subject_uuid');
+
+        // Create validation request
+        $createRegistryExtensionBundleRequest  = CreateRegistryExtensionBundleRequest::createFrom($request);
+        $rules                                 = $createRegistryExtensionBundleRequest->rules();
+
+        // Manually validate request
+        $validator = Validator::make($request->input('registryExtensionBundle'), $rules);
+        if ($validator->fails()) {
+            return $createRegistryExtensionBundleRequest->responseWithErrors($validator);
+        }
+
+        // Extract bundle extension json for file validation
+        $bundleFile = File::where('uuid', $request->input('registryExtensionBundle.bundle_uuid'))->first();
+        if (!$bundleFile) {
+            return response()->error('Unable to find bundle file for validation.');
+        }
+
+        // Get extension.json contents
+        $bundleData    = RegistryExtensionBundle::extractBundleData($bundleFile);
+        $extensionJson = Utils::getObjectKeyValue($bundleData, 'extension.json');
+        if (!$extensionJson) {
+            return response()->error('Unable to find `extension.json` file required in bundle.');
+        }
+
+        // Check if version is set
+        if (!isset($extensionJson->version)) {
+            return response()->error('No `version` set in the `extension.json`');
+        }
+
+        // Check if either api or engine property is set
+        if (!isset($extensionJson->engine) && !isset($extensionJson->api)) {
+            return response()->error('No `api` or `engine` property set in the `extension.json`');
+        }
+
+        // Set bundle number
+        $numberOfBundles = RegistryExtensionBundle::whereHas('extension', function ($query) use ($extensionId) {
+            $query->where('public_id', $extensionId);
+        })->count();
+        $extensionJson->bundle_number = ($numberOfBundles ?? 0) + 1;
+
+        try {
+            $record = $this->model->createRecordFromRequest($request);
+
+            // Update the record version from extension json
+            $record->update(['bundle_number' => $extensionJson->bundle_number, 'version' => $extensionJson->version]);
+            $record->updateMetaProperties((array) $bundleData);
+
+            return ['registryExtensionBundle' => new $this->resource($record)];
+        } catch (\Throwable $e) {
+            return response()->error($e->getMessage());
+        } catch (\Illuminate\Database\QueryException $e) {
+            return response()->error($e->getMessage());
+        } catch (FleetbaseRequestValidationException $e) {
+            return response()->error($e->getErrors());
+        }
+    }
+
+    /**
+     * Handles the download request for an extension bundle.
+     *
+     * This function retrieves a specific `RegistryExtension` by its ID and attempts to download
+     * its latest bundle. If the extension exists and has an associated bundle, it returns a download response
+     * with the appropriate file. If the extension doesn't exist or doesn't have a bundle, it returns an error response.
+     *
+     * @param RegistryExtensionActionRequest $request the validated request object
+     *
+     * @return \Symfony\Component\HttpFoundation\BinaryFileResponse|\Illuminate\Http\Response
+     *                                                                                        Returns a download response for the bundle if successful, or an error response if not
+     */
+    public function download(RegistryExtensionActionRequest $request)
+    {
+        $id              = $request->input('id');
+        $extensionBundle = RegistryExtensionBundle::find($id);
+        if ($extensionBundle && $extensionBundle->bundle) {
+            return Storage::disk($extensionBundle->bundle->disk)->download($extensionBundle->bundle->path, $extensionBundle->bundle->name);
+        }
+
+        return response()->error('Failed to download extension bundle');
+    }
+}

package/server/src/Http/Controllers/Internal/v1/RegistryExtensionController.php

@@ -0,0 +1,257 @@
+<?php
+
+namespace Fleetbase\RegistryBridge\Http\Controllers\Internal\v1;
+
+use Fleetbase\Exceptions\FleetbaseRequestValidationException;
+use Fleetbase\RegistryBridge\Http\Controllers\RegistryBridgeController;
+use Fleetbase\RegistryBridge\Http\Requests\CreateRegistryExtensionRequest;
+use Fleetbase\RegistryBridge\Http\Requests\RegistryExtensionActionRequest;
+use Fleetbase\RegistryBridge\Models\RegistryExtension;
+use Fleetbase\Support\Utils;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Storage;
+use Illuminate\Support\Facades\Validator;
+
+class RegistryExtensionController extends RegistryBridgeController
+{
+    /**
+     * The resource to query.
+     *
+     * @var string
+     */
+    public $resource = 'registry_extension';
+
+    /**
+     * Creates a record with request payload.
+     *
+     * @return \Illuminate\Http\Response
+     */
+    public function createRecord(Request $request)
+    {
+        // Create validation request
+        $createRegistryExtensionRequest  = CreateRegistryExtensionRequest::createFrom($request);
+        $rules                           = $createRegistryExtensionRequest->rules();
+
+        // Manually validate request
+        $validator = Validator::make($request->input('registryExtension'), $rules);
+        if ($validator->fails()) {
+            return $createRegistryExtensionRequest->responseWithErrors($validator);
+        }
+
+        try {
+            $record = $this->model->createRecordFromRequest($request);
+
+            return ['registryExtension' => new $this->resource($record)];
+        } catch (\Throwable $e) {
+            return response()->error($e->getMessage());
+        } catch (\Illuminate\Database\QueryException $e) {
+            return response()->error($e->getMessage());
+        } catch (FleetbaseRequestValidationException $e) {
+            return response()->error($e->getErrors());
+        }
+    }
+
+    /**
+     * Display a list of installed extensions for the current company.
+     *
+     * This function retrieves all extensions that are installed for the company
+     * identified by the `company_uuid` stored in the session. It disables the cache
+     * for the `RegistryExtension` model to ensure fresh data is fetched from the database.
+     *
+     * The extensions are filtered based on their association with any installation
+     * record that matches the `company_uuid` from the session. The resulting collection
+     * of installed extensions is then wrapped and returned as a resource collection.
+     *
+     * @return \Illuminate\Http\Resources\Json\AnonymousResourceCollection the collection of installed extensions wrapped as a resource
+     */
+    public function installed()
+    {
+        $installedExtensions = RegistryExtension::disableCache()->whereHas('installs', function ($query) {
+            $query->where('company_uuid', session('company'));
+        })->get();
+
+        $this->resource::wrap('registryExtensions');
+
+        return $this->resource::collection($installedExtensions);
+    }
+
+    /**
+     * Display a list of purchased extensions for the current company.
+     *
+     * This function retrieves all extensions that are purchased for the company
+     * identified by the `company_uuid` stored in the session. It disables the cache
+     * for the `RegistryExtension` model to ensure fresh data is fetched from the database.
+     *
+     * The extensions are filtered based on their association with any purchase
+     * record that matches the `company_uuid` from the session. The resulting collection
+     * of purchased extensions is then wrapped and returned as a resource collection.
+     *
+     * @return \Illuminate\Http\Resources\Json\AnonymousResourceCollection the collection of purchased extensions wrapped as a resource
+     */
+    public function purchased()
+    {
+        $purchasedExtensions = RegistryExtension::disableCache()->whereHas('purchases', function ($query) {
+            $query->where('company_uuid', session('company'));
+        })->get();
+
+        $this->resource::wrap('registryExtensions');
+
+        return $this->resource::collection($purchasedExtensions);
+    }
+
+    /**
+     * Retrieve analytics for a specific registry extension.
+     *
+     * This method fetches analytics for a registry extension identified by
+     * the provided ID. It gathers various metrics, including the number of
+     * installs, uninstalls, purchases, and the total purchase amount. If the
+     * extension cannot be found, it returns an error response. Otherwise, it
+     * returns the collected metrics as a JSON response.
+     *
+     * @param Request $request
+     *                         The incoming request instance containing the extension ID
+     *
+     * @return \Illuminate\Http\JsonResponse
+     *                                       A JSON response containing the collected analytics metrics or an error message
+     */
+    public function analytics(Request $request)
+    {
+        $id        = $request->input('id');
+        $extension = RegistryExtension::find($id);
+        if (!$extension) {
+            return response()->error('Unable to find extension to fetch analytics.');
+        }
+
+        $metrics = [];
+
+        // Get number of installs
+        $metrics['install_count'] = $extension->installs()->count();
+
+        // Get number of uninstalls
+        $metrics['uninstall_count'] = $extension->installs()->withoutGlobalScopes()->whereNotNull('deleted_at')->count();
+
+        // Get number of purchases
+        $metrics['purchase_count'] = $extension->purchases()->count();
+
+        // Get total amount in purchases
+        $totalPurchaseAmount        = $extension->purchases()->get()->sum('locked_price');
+        $metrics['purchase_amount'] = Utils::moneyFormat($totalPurchaseAmount, $extension->currency);
+
+        // Respond with metrics
+        return response()->json($metrics);
+    }
+
+    /**
+     * Approves a specific extension by its ID.
+     *
+     * This function locates a `RegistryExtension` using the provided ID and sets its status to 'approved'.
+     * If the extension is successfully found and updated, it returns the extension resource. If the extension
+     * cannot be found, it returns an error response indicating the inability to locate the extension.
+     *
+     * @param RegistryExtensionActionRequest $request the validated request object
+     *
+     * @return \Illuminate\Http\Response|array returns an array containing the extension resource if successful,
+     *                                         or an error response if the extension cannot be found
+     */
+    public function approve(RegistryExtensionActionRequest $request)
+    {
+        $id        = $request->input('id');
+        $extension = RegistryExtension::find($id);
+        if ($extension) {
+            $extension->update(['status' => 'approved', 'current_bundle_uuid' => $extension->next_bundle_uuid]);
+            $extension->nextBundle()->update(['status' => 'approved']);
+        } else {
+            return response()->error('Unable to find extension for approval.');
+        }
+
+        return ['registryExtension' => new $this->resource($extension)];
+    }
+
+    /**
+     * Rejects a specific extension by its ID.
+     *
+     * Locates a `RegistryExtension` using the provided ID and updates its status to 'rejected'. It also
+     * intends to send a rejection reason via email to the extension's author (as indicated by commented code).
+     * If the extension is found and updated, it returns the extension resource. If not found, it returns an
+     * error response indicating the extension could not be located.
+     *
+     * Note: This method assumes the rejection reason is handled separately (possibly by another request).
+     *
+     * @param RegistryExtensionActionRequest $request the validated request object
+     *
+     * @return \Illuminate\Http\Response|array returns an array containing the extension resource if successful,
+     *                                         or an error response if the extension cannot be found
+     */
+    public function reject(RegistryExtensionActionRequest $request)
+    {
+        $id        = $request->input('id');
+        $extension = RegistryExtension::find($id);
+        if ($extension) {
+            $extension->update(['status' => 'rejected']);
+            $extension->nextBundle()->update(['status' => 'rejected']);
+        } else {
+            return response()->error('Unable to find extension for rejection.');
+        }
+
+        // send rejection reason via email to extension author
+        // $reason = $request->input('reason');
+
+        return ['registryExtension' => new $this->resource($extension)];
+    }
+
+    /**
+     * Submits an extension for review based on its ID.
+     *
+     * This method attempts to submit a `RegistryExtension` for review. It first checks
+     * if the extension is ready for submission by calling the static method
+     * `isExtensionReadyForSubmission`. If the extension is not ready, it returns an error response.
+     * If the extension is ready, it updates the extension's status to 'awaiting_review' and returns
+     * a JSON response indicating success.
+     *
+     * @param string $id the unique identifier of the extension to be submitted
+     *
+     * @return \Illuminate\Http\JsonResponse returns a JSON response indicating the outcome of the operation
+     *
+     * @throws \Illuminate\Database\Eloquent\ModelNotFoundException if no extension with the given ID is found
+     */
+    public function submit(string $id)
+    {
+        $isReady = RegistryExtension::isExtensionReadyForSubmission($id);
+        if (!$isReady) {
+            return response()->error('Unable to submit extension for review.');
+        }
+
+        $extension = RegistryExtension::find($id);
+        if ($extension) {
+            $extension->update(['status' => 'awaiting_review']);
+        }
+
+        return ['registryExtension' => new $this->resource($extension)];
+    }
+
+    /**
+     * Handles the download request for an extension bundle.
+     *
+     * This function retrieves a specific `RegistryExtension` by its ID and attempts to download
+     * its latest bundle. If the extension exists and has an associated bundle, it returns a download response
+     * with the appropriate file. If the extension doesn't exist or doesn't have a bundle, it returns an error response.
+     *
+     * @param RegistryExtensionActionRequest $request the validated request object
+     *
+     * @return \Symfony\Component\HttpFoundation\BinaryFileResponse|\Illuminate\Http\Response
+     *                                                                                        Returns a download response for the bundle if successful, or an error response if not
+     */
+    public function downloadBundle(RegistryExtensionActionRequest $request)
+    {
+        $id        = $request->input('id');
+        $extension = RegistryExtension::find($id);
+        if ($extension && $extension->nextBundle) {
+            $bundleFile = data_get($extension, 'nextBundle.bundle');
+            if ($bundleFile) {
+                return Storage::disk($bundleFile->disk)->download($bundleFile->path, $bundleFile->name);
+            }
+        }
+
+        return response()->error('Failed to download extension bundle');
+    }
+}

package/server/src/Http/Controllers/Internal/v1/RegistryPaymentsController.php

@@ -0,0 +1,227 @@
+<?php
+
+namespace Fleetbase\RegistryBridge\Http\Controllers\Internal\v1;
+
+use Fleetbase\Http\Controllers\Controller;
+use Fleetbase\Http\Resources\FleetbaseResource;
+use Fleetbase\RegistryBridge\Models\RegistryExtension;
+use Fleetbase\RegistryBridge\Models\RegistryExtensionPurchase;
+use Fleetbase\RegistryBridge\Support\Utils;
+use Fleetbase\Support\Auth;
+use Illuminate\Http\Request;
+use Illuminate\Support\Str;
+
+/**
+ * Handles payment processing and Stripe account management for registry extensions.
+ *
+ * This controller provides functionalities such as checking if a company has a Stripe Connect account,
+ * creating Stripe accounts, managing Stripe account sessions, and handling Stripe Checkout sessions.
+ */
+class RegistryPaymentsController extends Controller
+{
+    /**
+     * Checks if the currently authenticated company has an associated Stripe Connect account.
+     *
+     * This method verifies if the authenticated company has a Stripe Connect ID that starts with 'acct_'.
+     *
+     * @return \Illuminate\Http\JsonResponse returns a JSON response indicating the presence of a Stripe Connect account
+     */
+    public function hasStripeConnectAccount()
+    {
+        $company = Auth::getCompany();
+        if ($company) {
+            return response()->json([
+                'hasStripeConnectAccount' => !empty($company->stripe_connect_id) && Str::startsWith($company->stripe_connect_id, 'acct_'),
+            ]);
+        }
+
+        return response()->json([
+            'hasStripeConnectAccount' => false,
+        ]);
+    }
+
+    /**
+     * Creates a new Stripe account for the currently authenticated company and stores the account ID.
+     *
+     * This method utilizes the Fleetbase utility class to create a Stripe Express account and saves the
+     * Stripe account ID to the current company's profile. In case of failure, it returns an error.
+     *
+     * @return \Illuminate\Http\JsonResponse returns the Stripe account ID or an error message in JSON format
+     */
+    public function getStripeAccount()
+    {
+        $stripe = Utils::getStripeClient();
+
+        try {
+            $account = $stripe->accounts->create([
+                'controller' => [
+                    'stripe_dashboard' => [
+                        'type' => 'express',
+                    ],
+                    'fees' => [
+                        'payer' => 'application',
+                    ],
+                    'losses' => [
+                        'payments' => 'application',
+                    ],
+                ],
+            ]);
+
+            // Save account ID to current company session
+            $company = Auth::getCompany();
+            if ($company) {
+                $company->update(['stripe_connect_id' => $account->id]);
+            }
+
+            return response()->json(['account' => $account->id]);
+        } catch (\Exception $e) {
+            return response()->error($e->getMessage());
+        }
+    }
+
+    /**
+     * Creates a Stripe account session for account onboarding or management.
+     *
+     * This method creates a session for the current company's Stripe account, allowing for onboarding or management activities.
+     * It accepts an 'account' parameter from the request, defaulting to the company's stored Stripe Connect ID if not provided.
+     *
+     * @param Request $request the incoming HTTP request containing optional 'account' parameter
+     *
+     * @return \Illuminate\Http\JsonResponse returns a JSON response with the session's client secret or an error message
+     */
+    public function getStripeAccountSession(Request $request)
+    {
+        $stripe  = Utils::getStripeClient();
+        $company = Auth::getCompany();
+
+        try {
+            $accountSession = $stripe->accountSessions->create([
+                'account'    => $request->input('account', $company->stripe_connect_id),
+                'components' => [
+                    'account_onboarding' => [
+                        'enabled' => true,
+                    ],
+                ],
+            ]);
+
+            return response()->json([
+                'clientSecret' => $accountSession->client_secret,
+            ]);
+        } catch (\Exception $e) {
+            return response()->error($e->getMessage());
+        }
+    }
+
+    /**
+     * Creates a Stripe Checkout session for a specified registry extension.
+     *
+     * This method initializes a checkout session for purchasing a registry extension identified by a UUID.
+     * It requires a 'uri' for redirection after the checkout and an 'extension' UUID to identify the product.
+     *
+     * @param Request $request the incoming HTTP request with 'uri' and 'extension' parameters
+     *
+     * @return \Illuminate\Http\JsonResponse returns the checkout session's client secret or an error message
+     */
+    public function createStripeCheckoutSession(Request $request)
+    {
+        $redirectUri       = $request->input('uri');
+        $extension         = RegistryExtension::where('uuid', $request->input('extension'))->first();
+        if (!$extension) {
+            return response()->error('The extension you attempted to purchase does not exist.');
+        }
+
+        try {
+            $checkoutSession = $extension->createStripeCheckoutSession($redirectUri);
+        } catch (\Throwable $e) {
+            return response()->error($e->getMessage());
+        }
+
+        return response()->json(['clientSecret' => $checkoutSession->client_secret]);
+    }
+
+    /**
+     * Retrieves the status of an ongoing Stripe Checkout session.
+     *
+     * This method checks the status of a Stripe Checkout session associated with a registry extension purchase.
+     * It ensures the extension exists and checks if it has already been purchased. It then retrieves and returns
+     * the checkout session status or creates a purchase record if the session is complete.
+     *
+     * @param Request $request the incoming HTTP request containing 'extension' and 'checkout_session_id'
+     *
+     * @return \Illuminate\Http\JsonResponse returns the checkout session status or an error message
+     */
+    public function getStripeCheckoutSessionStatus(Request $request)
+    {
+        $extension = RegistryExtension::where('uuid', $request->input('extension'))->first();
+        if (!$extension) {
+            return response()->error('The extension you attempted to purchase does not exist.');
+        }
+
+        // Flush cache for extension
+        if (method_exists($extension, 'flushCache')) {
+            $extension->flushCache();
+        }
+
+        // Check if already purchased
+        $purchaseRecordExists = RegistryExtensionPurchase::where(['company_uuid' => session('company'), 'extension_uuid' => $extension->uuid])->exists();
+        if ($purchaseRecordExists) {
+            return response()->json(['status' => 'purchase_complete', 'extension' => $extension]);
+        }
+
+        $stripe          = Utils::getStripeClient();
+        try {
+            $session = $stripe->checkout->sessions->retrieve($request->input('checkout_session_id'));
+            if (isset($session->status) && $session->status === 'complete') {
+                RegistryExtensionPurchase::firstOrCreate(
+                    [
+                        'company_uuid'   => session('company'),
+                        'extension_uuid' => $extension->uuid,
+                    ],
+                    [
+                        'stripe_checkout_session_id' => $session->id,
+                        'stripe_payment_intent_id'   => $session->payment_intent,
+                        'locked_price'               => $session->amount_total,
+                    ]
+                );
+            }
+
+            // Flush cache for extension
+            if (method_exists($extension, 'flushCache')) {
+                $extension->flushCache();
+            }
+
+            return response()->json(['status' => $session->status, 'extension' => $extension]);
+        } catch (\Error $e) {
+            return response()->error($e->getMessage());
+        }
+    }
+
+    public function getAuthorReceivedPayments(Request $request)
+    {
+        $limit     = $request->input('limit', 30);
+        $query     = RegistryExtensionPurchase::whereHas(
+            'extension',
+            function ($query) {
+                $query->where('company_uuid', session('company'));
+            }
+        )->with(
+            [
+                'extension' => function ($query) {
+                    $query->select(['uuid', 'public_id', 'name', 'category_uuid']);
+                    $query->with(['category']);
+                },
+                'company' => function ($query) {
+                    $query->select(['uuid', 'name'])->withoutGlobalScopes();
+                },
+            ]
+        );
+
+        // Handle sorting
+        app(RegistryExtensionPurchase::class)->applySorts($request, $query);
+
+        $payments                   = $query->fastPaginate($limit);
+        $totalPurchaseAmount        = $query->get()->sum('locked_price');
+
+        return FleetbaseResource::collection($payments)->additional(['total_amount' => $totalPurchaseAmount]);
+    }
+}

package/server/src/Http/Controllers/RegistryBridgeController.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Fleetbase\RegistryBridge\Http\Controllers;
+
+use Fleetbase\Http\Controllers\FleetbaseController;
+
+class RegistryBridgeController extends FleetbaseController
+{
+    /**
+     * The package namespace used to resolve from.
+     */
+    public string $namespace = '\\Fleetbase\\RegistryBridge';
+}

package/server/src/Http/Filter/RegistryExtensionFilter.php

@@ -0,0 +1,80 @@
+<?php
+
+namespace Fleetbase\RegistryBridge\Http\Filter;
+
+use Fleetbase\Http\Filter\Filter;
+use Fleetbase\Support\Utils;
+use Illuminate\Support\Str;
+
+class RegistryExtensionFilter extends Filter
+{
+    public function queryForInternal()
+    {
+        if ($this->request->boolean('explore')) {
+            return;
+        }
+        $this->builder->where('company_uuid', $this->session->get('company'));
+    }
+
+    public function queryForPublic()
+    {
+        $this->builder->where('company_uuid', $this->session->get('company'));
+    }
+
+    public function query(?string $searchQuery)
+    {
+        $this->builder->search($searchQuery);
+    }
+
+    public function isAuthor()
+    {
+        $this->builder->where('company_uuid', session('company'));
+    }
+
+    public function explore()
+    {
+        $this->builder->where('status', 'published');
+        $this->builder->without(['current_bundle', 'next_bundle', 'category']);
+        $this->builder->with(['screenshots']);
+    }
+
+    public function category($category)
+    {
+        if (Str::isUuid($category)) {
+            return $this->builder->where('category_uuid', $category);
+        }
+
+        if (Utils::isPublicId($category)) {
+            return $this->builder->whereHas('category', function ($query) use ($category) {
+                $query->where('public_id', $category)->where('for', 'extension_category')->where('core_category', 1);
+            });
+        }
+
+        // assume slug
+        return $this->builder->whereHas('category', function ($query) use ($category) {
+            $query->where('slug', $category)->where('for', 'extension_category')->where('core_category', 1);
+        });
+    }
+
+    public function createdAt($createdAt)
+    {
+        $createdAt = Utils::dateRange($createdAt);
+
+        if (is_array($createdAt)) {
+            $this->builder->whereBetween('created_at', $createdAt);
+        } else {
+            $this->builder->whereDate('created_at', $createdAt);
+        }
+    }
+
+    public function updatedAt($updatedAt)
+    {
+        $updatedAt = Utils::dateRange($updatedAt);
+
+        if (is_array($updatedAt)) {
+            $this->builder->whereBetween('updated_at', $updatedAt);
+        } else {
+            $this->builder->whereDate('updated_at', $updatedAt);
+        }
+    }
+}