@fleetbase/storefront-engine 0.1.7 → 0.1.8

package/server/src/Http/Controllers/v1/NetworkController.php

@@ -0,0 +1,281 @@
+<?php
+
+namespace Fleetbase\Storefront\Http\Controllers\v1;
+
+use Fleetbase\Http\Controllers\Controller;
+use Fleetbase\Storefront\Http\Resources\Store as StorefrontStore;
+use Fleetbase\Storefront\Http\Resources\StoreLocation as StorefrontStoreLocation;
+use Fleetbase\Storefront\Models\Store;
+use Fleetbase\Storefront\Models\StoreLocation;
+use Fleetbase\Models\Category;
+use Fleetbase\FleetOps\Support\Utils;
+use Grimzy\LaravelMysqlSpatial\Types\Point;
+use Illuminate\Http\Request;
+
+class NetworkController extends Controller
+{
+    /**
+     * Returns all stores within the network.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Illuminate\Http\Response
+     */
+    public function stores(Request $request)
+    {
+        if (session('storefront_store')) {
+            return response()->error('Stores cannot have stores!');
+        }
+
+        $sort = $request->input('sort', false);
+        $limit = $request->input('limit', false);
+        $offset = $request->input('offset', false);
+        $ids = $request->input('ids', []);
+        $tagged = $request->input('tagged', []);
+        $query = $request->input('query', false);
+        $location = $request->input('location');
+        $maxDistance = $request->input('maximum_distance', null);
+        $exclude = $request->input('exclude', []);
+
+        if (is_string($tagged)) {
+            $tagged = explode(',', $tagged);
+        }
+
+        if (is_string($exclude)) {
+            $exclude = explode(',', $exclude);
+        }
+
+        if (is_string($ids)) {
+            $ids = explode(',', $ids);
+        }
+
+        /** @var \Illuminate\Database\Query\Builder $query */
+        $query = Store::select('*')
+            ->where('company_uuid', session('company'))
+            ->with(['logo', 'backdrop', 'media'])
+            ->whereHas('locations')
+            ->whereHas('networks', function ($q) use ($request) {
+                $q->where('network_uuid', session('storefront_network'));
+
+                // Query stores without a category
+                if ($request->filled('without_category')) {
+                    $q->whereNull('category_uuid');
+                }
+
+                // Query stores by category
+                if ($request->filled('category')) {
+                    $category = Category::select('uuid')->where('public_id', $request->input('category'))->first();
+                    $q->where('category_uuid', $category->uuid);
+                    // $q->whereHas('category', function ())
+                }
+            });
+
+        // query stores using tags provided
+        if (!empty($tagged)) {
+            $query->where(function ($q) use ($tagged) {
+                foreach ($tagged as $tag) {
+                    $q->orWhereJsonContains('tags', $tag);
+                }
+            });
+        }
+
+        // if we need to exclude specific stores
+        if (!empty($exclude)) {
+            $query->where(function ($q) use ($exclude) {
+                $q->whereNotIn('public_id', $exclude);
+            });
+        }
+
+        // if query for specific ids
+        if (!empty($ids)) {
+            $query->where(function ($q) use ($ids) {
+                $q->whereIn('public_id', $ids);
+            });
+        }
+
+        // only get stores with `StoreLocation` within $maxDistance (meters)
+        // need to move place->location as alias column to storeLocation->location
+        // when place gets updated/changed it also updates corresponding storeLocation in observer
+        // if ($location && $maxDistance) {
+        //     $query->whereHas('locations', function ($q) use ($maxDistance) {
+        //     });
+        // }
+
+        switch ($sort) {
+            case 'highest_rated':
+                $query->withAvg('reviews', 'rating')->orderByDesc('reviews_avg_rating');
+            case 'lowest_rated':
+                $query->withAvg('reviews', 'rating')->orderBy('reviews_avg_rating');
+            case 'newest':
+                $query->orderByDesc('created_at');
+            case 'oldest':
+                $query->orderBy('created_at');
+            case 'popular':
+                $query->withCount('checkouts')->orderByDesc('checkouts_count');
+        }
+
+        if ($limit) {
+            $query->limit($limit);
+        }
+
+        if ($offset) {
+            $query->offset($offset);
+        }
+
+        $stores = $query->get();
+
+        // handle nearest sort special case due to location depth
+        if ($sort === 'nearest' && $location) {
+            $coordinates = Utils::getPointFromCoordinates($location);
+
+            $stores = $stores->sort(function ($storeA, $storeB) use ($coordinates) {
+                $distanceA = $storeA->locations->sort(function ($locationA, $locationB) use ($coordinates) {
+                    $distanceA = Utils::vincentyGreatCircleDistance($coordinates, $locationA->place->location);
+                    $distanceB = Utils::vincentyGreatCircleDistance($coordinates, $locationB->place->location);
+
+                    return $distanceA - $distanceB;
+                })->map(function ($location) use ($coordinates) {
+                    $location->distance = Utils::vincentyGreatCircleDistance($coordinates, $location->place->location);
+                    return $location;
+                })->first()->distance;
+
+                $distanceB = $storeB->locations->sort(function ($locationA, $locationB) use ($coordinates) {
+                    $distanceA = Utils::vincentyGreatCircleDistance($coordinates, $locationA->place->location);
+                    $distanceB = Utils::vincentyGreatCircleDistance($coordinates, $locationB->place->location);
+
+                    return $distanceA - $distanceB;
+                })->map(function ($location) use ($coordinates) {
+                    $location->distance = Utils::vincentyGreatCircleDistance($coordinates, $location->place->location);
+                    return $location;
+                })->first()->distance;
+
+                return $distanceA - $distanceB;
+            });
+        }
+
+        // sort trending ( most checkouts within 24h )
+        if ($sort === 'trending') {
+            $stores = $stores->sortByDesc('24h_checkouts_count');
+        }
+
+        return StorefrontStore::collection($stores);
+    }
+
+    /**
+     * Returns all store locations within the network.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Illuminate\Http\Response
+     */
+    public function storeLocations(Request $request)
+    {
+        $limit = $request->input('limit', 30);
+        $ids = $request->input('ids', []);
+        $exclude = $request->input('exclude', []);
+        $offset = $request->input('offset');
+        $location = $request->input('location');
+        $tagged = $request->input('tagged', []);
+        $searchQuery = $request->input('query', false);
+        $shouldIncludeStore = $request->input('with_store', false);
+        $coordinates = Utils::getPointFromCoordinates($location);
+
+        if (is_string($tagged)) {
+            $tagged = explode(',', $tagged);
+        }
+
+        if (is_string($exclude)) {
+            $exclude = explode(',', $exclude);
+        }
+
+        if (is_string($ids)) {
+            $ids = explode(',', $ids);
+        }
+
+        $databaseName = config('database.connections.mysql.database');
+        $placesTableName = $databaseName . '.places';
+
+        $query = StoreLocation::select(['store_locations.*', $placesTableName . '.location', $placesTableName . '.uuid'])
+            ->join($placesTableName, $placesTableName . '.uuid', '=', 'store_locations.place_uuid')
+            ->whereHas('store', function ($q) use ($tagged, $searchQuery) {
+                $q->whereHas('networks', function ($q) {
+                    $q->where('network_uuid', session('storefront_network'));
+                });
+
+                if (!empty($tagged)) {
+                    $q->where(function ($q) use ($tagged) {
+                        foreach ($tagged as $tag) {
+                            $q->orWhereJsonContains('tags', $tag);
+                        }
+                    });
+                }
+
+                if ($searchQuery) {
+                    $q->search($searchQuery);
+                }
+            });
+
+        if ($shouldIncludeStore) {
+            $query->with('store');
+        }
+
+        // if we need to exclude specific stores
+        if (!empty($exclude)) {
+            $query->where(function ($q) use ($exclude) {
+                $q->whereNotIn('store_locations.public_id', $exclude);
+            });
+        }
+
+        // if query for specific ids
+        if (!empty($ids)) {
+            $query->where(function ($q) use ($ids) {
+                $q->whereIn('store_locations.public_id', $ids);
+            });
+        }
+
+        if ($limit) {
+            $query->limit($limit);
+        }
+
+        if ($offset) {
+            $query->offset($offset);
+        }
+
+        if ($coordinates instanceof Point) {
+            $query->orderByDistance('location', $coordinates);
+        }
+
+        $locations = $query->get();
+
+        return StorefrontStoreLocation::collection($locations);
+    }
+
+    /**
+     * Returns all tags from stores/categories throughout the network
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Illuminate\Http\Response
+     */
+    public function tags(Request $request)
+    {
+        $tags = [];
+
+        $stores = Store::select(['tags'])
+            ->whereHas('locations')
+            ->whereHas('networks', function ($q) {
+                $q->where('network_uuid', session('storefront_network'));
+            })->get();
+
+        foreach ($stores as $store) {
+            $tags = array_merge($tags, $store->tags ?? []);
+        }
+
+        // $categories = Category::select(['tags'])->where(['owner_uuid' => session('storefront_network'), 'for' => 'storefront_network']);
+        // foreach ($categories as $category) {
+        //     $tags = array_merge($tags, $category->tags ?? []);
+        // }
+
+        // unique only
+        $tags = array_values(array_unique($tags));
+
+        return response()->json($tags);
+    }
+}

package/server/src/Http/Controllers/v1/PaymentMethodController.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Fleetbase\Storefront\Http\Controllers\v1;
+
+use Fleetbase\Http\Controllers\Controller;
+use Illuminate\Http\Request;
+
+class PaymentMethodController extends Controller
+{
+    //
+}

package/server/src/Http/Controllers/v1/ProductController.php

@@ -0,0 +1,94 @@
+<?php
+
+namespace Fleetbase\Storefront\Http\Controllers\v1;
+
+use Fleetbase\Http\Controllers\Controller;
+use Fleetbase\Storefront\Http\Resources\Product as StorefrontProduct;
+use Fleetbase\Http\Resources\v1\DeletedResource;
+use Fleetbase\Models\Category;
+use Fleetbase\Storefront\Models\Product;
+use Illuminate\Database\Eloquent\ModelNotFoundException;
+use Illuminate\Http\Request;
+
+class ProductController extends Controller
+{
+    /**
+     * Query for Storefront Product resources.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Fleetbase\Http\Resources\DriverCollection
+     */
+    public function query(Request $request)
+    {
+        $results = Product::queryWithRequest($request, function (&$query, $request) {
+            // for stores
+            if (session('storefront_store')) {
+                $query->where(['store_uuid' => session('storefront_store')]);
+            }
+
+            // for networks
+            if (session('storefront_network')) {
+                $query->whereHas('store', function ($sq) {
+                    $sq->whereHas('networks', function ($nq) {
+                        $nq->where('network_uuid', session('storefront_network'));
+                    });
+                });
+            }
+
+            // @todo When done dev is completed make sure status is published - also add status field to product view
+            $query->where('is_available', 1);
+            $query->with(['addonCategories.category', 'variants.options', 'files']);
+
+            if ($request->filled('category')) {
+                $category = Category::where(['public_id' => $request->input('category'), 'for' => 'storefront_product'])->first();
+
+                if ($category) {
+                    $query->where('category_uuid', $category->uuid);
+                }
+            }
+        });
+
+        return StorefrontProduct::collection($results);
+    }
+
+    /**
+     * Finds a single Storefront Product resources.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Fleetbase\Http\Resources\EntityCollection
+     */
+    public function find($id)
+    {
+        // find for the product
+        try {
+            $product = Product::findRecordOrFail($id);
+        } catch (ModelNotFoundException $exception) {
+            return response()->error('Product resource not found.');
+        }
+
+        // response the product resource
+        return new StorefrontProduct($product);
+    }
+
+    /**
+     * Deletes a Storefront Product resources.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Fleetbase\Http\Resources\v1\DeletedResource
+     */
+    public function delete($id)
+    {
+        // find for the product
+        try {
+            $product = Product::findRecordOrFail($id);
+        } catch (ModelNotFoundException $exception) {
+            return response()->error('Product resource not found.');
+        }
+
+        // delete the product
+        $product->delete();
+
+        // response the product resource
+        return new DeletedResource($product);
+    }
+}

package/server/src/Http/Controllers/v1/ReviewController.php

@@ -0,0 +1,270 @@
+<?php
+
+namespace Fleetbase\Storefront\Http\Controllers\v1;
+
+use Fleetbase\Http\Controllers\Controller;
+use Fleetbase\Storefront\Http\Requests\CreateReviewRequest;
+use Fleetbase\Storefront\Http\Resources\Review as StorefrontReview;
+use Fleetbase\FleetOps\Http\Resources\v1\DeletedResource;
+use Fleetbase\Storefront\Models\Store;
+use Fleetbase\Storefront\Models\Review;
+use Fleetbase\Storefront\Support\Storefront;
+use Fleetbase\FleetOps\Support\Utils;
+use Fleetbase\Models\File;
+use Illuminate\Database\Eloquent\ModelNotFoundException;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Storage;
+
+class ReviewController extends Controller
+{
+    /**
+     * Query for Storefront Review resources.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Illuminate\Http\Response
+     */
+    public function query(Request $request)
+    {
+        $limit = $request->input('limit', false);
+        $offset = $request->input('offset', false);
+        $sort = $request->input('sort');
+
+        if (session('storefront_store')) {
+            $results = Review::queryWithRequest($request, function (&$query) use ($limit, $offset, $sort) {
+                $query->where('subject_uuid', session('storefront_store'));
+
+                if ($limit) {
+                    $query->limit($limit);
+                }
+
+                if ($offset) {
+                    $query->limit($offset);
+                }
+
+                if ($sort) {
+                    switch ($sort) {
+                        case 'highest':
+                        case 'highest rated':
+                            $query->orderByDesc('rating');
+                            break;
+
+                        case 'lowest':
+                        case 'lowest rated':
+                            $query->orderBy('rating');
+                            break;
+
+                        case 'newest':
+                        case 'newest first':
+                            $query->orderByDesc('created_at');
+                            break;
+
+                        case 'oldest':
+                        case 'oldest first':
+                            $query->orderBy('created_at');
+                            break;
+                    }
+                }
+            });
+        }
+
+        if (session('storefront_network')) {
+            if ($request->filled('store')) {
+                $store = Store::where([
+                    'company_uuid' => session('company'),
+                    'public_id' => $request->input('store')
+                ])->whereHas('networks', function ($q) {
+                    $q->where('network_uuid', session('storefront_network'));
+                })->first();
+
+                if (!$store) {
+                    return response()->json(['error' => 'Cannot find reviews for store'], 400);
+                }
+
+                $results = Review::queryWithRequest($request, function (&$query) use ($store, $sort, $limit, $offset) {
+                    $query->where('subject_uuid', $store->uuid);
+
+                    if ($limit) {
+                        $query->limit($limit);
+                    }
+
+                    if ($offset) {
+                        $query->limit($offset);
+                    }
+
+                    if ($sort) {
+                        switch ($sort) {
+                            case 'highest':
+                            case 'highest rated':
+                                $query->orderByDesc('rating');
+                                break;
+
+                            case 'lowest':
+                            case 'lowest rated':
+                                $query->orderBy('rating');
+                                break;
+
+                            case 'newest':
+                            case 'newest first':
+                                $query->orderByDesc('created_at');
+                                break;
+
+                            case 'oldest':
+                            case 'oldest first':
+                                $query->orderBy('created_at');
+                                break;
+                        }
+                    }
+                });
+            }
+        }
+
+        return StorefrontReview::collection($results);
+    }
+
+    /**
+     * Coutns the number of ratings between 1-5 for a store.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Illuminate\Http\Response
+     */
+    public function count(Request $request)
+    {
+        $counts = [];
+        $range = range(1, 5);
+
+        if (session('storefront_store')) {
+            foreach ($range as $rating) {
+                $counts[$rating] = Review::where(['subject_uuid' => session('storefront_store'), 'rating' => $rating])->count();
+            }
+        }
+
+        if (session('storefront_network')) {
+            if ($request->filled('store')) {
+                $store = Store::where([
+                    'company_uuid' => session('company'),
+                    'public_id' => $request->input('store')
+                ])->whereHas('networks', function ($q) {
+                    $q->where('network_uuid', session('storefront_network'));
+                })->first();
+
+                if (!$store) {
+                    return response()->json(['error' => 'Cannot count reviews for store'], 400);
+                }
+
+                foreach ($range as $rating) {
+                    $counts[$rating] = Review::where(['subject_uuid' => $store->uuid, 'rating' => $rating])->count();
+                }
+            }
+        }
+
+        return response()->json($counts);
+    }
+
+    /**
+     * Finds a single Storefront Review resources.
+     *
+     * @param  string $id
+     * @return \Fleetbase\Http\Response
+     */
+    public function find($id)
+    {
+        // find for the review
+        try {
+            $review = Review::findRecordOrFail($id);
+        } catch (ModelNotFoundException $exception) {
+            return response()->error('Review resource not found.');
+        }
+
+        // response the review resource
+        return new StorefrontReview($review);
+    }
+
+    /**
+     * Create a review.
+     *
+     * @param  \Fleetbase\Storefront\Http\Requests\CreateReviewRequest  $request
+     * @return \Fleetbase\Http\Response
+     */
+    public function create(CreateReviewRequest $request)
+    {
+        $customer = Storefront::getCustomerFromToken();
+        $about = Storefront::about();
+
+        if (!$customer) {
+            return response()->error('Not authorized to create reviews');
+        }
+
+        $subject = Utils::resolveSubject($request->input('subject'));
+
+        if (!$subject) {
+            return response()->error('Invalid subject for review');
+        }
+
+        $review = Review::create([
+            'created_by_uuid' => $customer->user_uuid,
+            'customer_uuid' => $customer->uuid,
+            'subject_uuid' => $subject->uuid,
+            'subject_type' => Utils::getMutationType($subject),
+            'rating' => $request->input('rating'),
+            'content' => $request->input('content')
+        ]);
+
+        // if files provided
+        if ($request->filled('files')) {
+            $files = $request->input('files');
+
+            foreach ($files as $upload) {
+
+                $data = Utils::get($upload, 'data');
+                $mimeType = Utils::get($upload, 'type');
+                $extension = File::getExtensionFromMimeType($mimeType);
+                $bucketPath = 'hyperstore/' . $about->public_id . '/review-photos/' . $review->uuid . '/' . File::randomFileName($extension);
+
+                // upload file to path
+                $upload = Storage::disk('s3')->put($bucketPath, base64_decode($data), 'public');
+
+                // create the file
+                $file = File::create([
+                    'company_uuid' => session('company'),
+                    'uploader_uuid' => $customer->user_uuid,
+                    'subject_uuid' => $review->uuid,
+                    'subject_type' => Utils::getMutationType($review),
+                    'name' => basename($bucketPath),
+                    'original_filename' => basename($bucketPath),
+                    'extension' => $extension,
+                    'content_type' => $mimeType,
+                    'path' => $bucketPath,
+                    'bucket' => config('filesystems.disks.s3.bucket'),
+                    'type' => 'storefront_review_upload',
+                    'size' => Utils::getBase64ImageSize($data)
+                ]);
+
+                $review->files->push($file);
+            }
+        }
+
+        return new StorefrontReview($review);
+    }
+
+    /**
+     * Deletes a Storefront Review resources.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Fleetbase\Http\Resources\v1\DeletedResource
+     */
+    public function delete($id)
+    {
+        // find for the product
+        try {
+            $review = Review::findRecordOrFail($id);
+        } catch (ModelNotFoundException $exception) {
+            return response()->error('Review resource not found.');
+        }
+
+        // delete the review
+        $review->delete();
+
+        // response the review resource
+        return new DeletedResource($review);
+    }
+}