%PDF- %PDF-
Mini Shell

Mini Shell

Direktori : /var/www/html/geotechnics/api/app/Http/Controllers/Api/v1/
Upload File :
Create Path :
Current File : /var/www/html/geotechnics/api/app/Http/Controllers/Api/v1/ServicesController.php

<?php

namespace App\Http\Controllers\Api\v1;

use App\Http\Controllers\Api\ApiController;
use App\Http\Requests\Api\v1\Services\ServiceRequest;
use App\Models\Service;
use App\Models\User;
use App\Transformers\MediaTransformer;
use App\Transformers\ServiceTransformer;
use Flow\Config;
use Flow\File;
use Flow\Request as FlowRequest;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Pagination\LengthAwarePaginator;
use Spatie\Fractal\Fractal;
use Spatie\MediaLibrary\Models\Media;

class ServicesController extends ApiController
{
    /**
     * @param Request $request
     * @return Fractal
     */
    public function index(Request $request)
    {
        /** @var User $user */
        $user = auth()
            ->guard('api')
            ->user();
        /** @var LengthAwarePaginator $result */
        $result = Service::query();
        if (!$user->isAdmin()) {
            $result = $result->where('client_id', null)
                             ->orWhere('client_id', $user->id);
        }

        if ($name = $request->get('name')) {
            $result = $result->where('name', 'like', "$name%");
        }
        if ($description = $request->get('description')) {
            $result = $result->where('description', 'like', "$description%");
        }
        $result = $result->paginate($request->get('perPage'));
        return $this->withPaginated($result, new ServiceTransformer());
    }


    /**
     * @param $id
     * @return JsonResponse
     */
    public function show($id)
    {
        $service = Service::query()
                          ->find($id);
        return $this->item($service, new ServiceTransformer());
    }

    public function store(ServiceRequest $request)
    {
        /** @var Service $service */
        $service = Service::query()
                          ->make($request->only(['name', 'description', 'long_description', 'price']));
        $user = $service->getLoggedInUser();
        if ($user->isAdmin()) {
            $service->category()
                    ->associate($request->get('category_id'));
        } else {
            $service->is_available = true;
            $service->client()
                    ->associate($user);
        }
        $service->save();
        return $this->item($service, new ServiceTransformer());
    }

    /**
     * @param ServiceRequest $request
     * @param $id
     * @return JsonResponse
     */
    public function update(ServiceRequest $request, $id)
    {
        /** @var Service $service */
        $service = Service::query()
                          ->findOrFail($id);
        $service->update($request->only(['name', 'description', 'long_description', 'price']));
        $service->category()
                ->associate($request->get('category_id'));
        $service->save();
        return $this->item($service, new ServiceTransformer());
    }

    /**
     * @param $id
     * @return JsonResponse
     */
    public function enable($id)
    {
        try {
            /** @var Service $service */
            $service = Service::query()
                              ->findOrFail($id);
            $service->enable();
            return $this->item($service, new ServiceTransformer());
        } catch (\Exception $e) {
            return $this->methodForbidden();
        }
    }

    /**
     * @param $id
     * @return JsonResponse
     */
    public function disable($id)
    {
        try {
            /** @var Service $service */
            $service = Service::query()
                              ->findOrFail($id);
            $service->disable();
            return $this->item($service, new ServiceTransformer);
        } catch (\Exception $e) {
            return $this->methodForbidden();
        }
    }

    public function uploadDocument(Service $service)
    {
        $fileName = md5(time());;
        $request = new FlowRequest();

        $config = new Config([
            'tempDir' => storage_path('app/flow/chunks'),
        ]);

        $file = new File($config, $request);
        $realFileName = $request->getParam('flowFilename');
        $ext = last(explode('.', $realFileName));
        $destination = storage_path("app/flow/uploads/$fileName.$ext}");

        if (request()->isMethod('GET')) {
            if (!$file->checkChunk()) {
                return response()->make('', 204);
            }
        } else {
            if ($file->validateChunk()) {
                $file->saveChunk();
            } else {
                return $this->wrongArguments('test');
            }
        }
        try {
            if ($file->validateFile() && $file->save($destination)) {
                if ($currentMedia = $service->media()
                                            ->first()) {
                    $currentMedia->delete();
                }
                $media = $service->addMedia($destination)
                                 ->usingName($fileName)
                                 ->usingFileName("$fileName.$ext")
                                 ->toMediaCollection(Service::MEDIA_DISK);
                $media->setCustomProperty('filename', $request->getFileName());
                $media->save();
                return $this->item($media, new MediaTransformer());
            }
            return response(['message' => 'ok'], 200);
        } catch (\Exception $e) {
            return $this->wrongArguments($e->getMessage());
        }
    }

    public function downloadDocuments(Service $service)
    {
        /** @var Media $item */
        $item = $service->media()
                        ->first();

        $fullUrl = storage_path("app/public/$item->id/$item->file_name");
        return response()->download($fullUrl);
    }

}

Zerion Mini Shell 1.0