%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/ProjectsController.php

<?php

namespace App\Http\Controllers\Api\v1;

use App\Http\Controllers\Api\ApiController;
use App\Http\Requests\Api\v1\Projects\CreateProjectRequest;
use App\Http\Requests\Api\v1\Users\UploadImageRequest;
use App\Models\FolderName;
use App\Models\Project;
use App\Models\ProjectNote;
use App\Models\ProjectStatus;
use App\Models\Service;
use App\Models\User;
use App\Notifications\NotifyAdminForRequestQuotation;
use App\Transformers\FolderNameTransformer;
use App\Transformers\MediaTransformer;
use App\Transformers\ProjectDetailTransformer;
use App\Transformers\ProjectTransformer;
use App\Transformers\ServiceTransformer;
use App\Transformers\UserTransformer;
use Chumper\Zipper\Zipper as Zipper;
use Flow\Config;
use Flow\File;
use Flow\Request as FlowRequest;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Spatie\MediaLibrary\Models\Media;

class ProjectsController extends ApiController
{
    /**
     * User $user.
     */
    protected $user;
    /**
     * @var Zipper
     */
    private $zipper;

    /**
     * PostsController constructor.
     * @param Zipper $zipper
     */
    public function __construct(Zipper $zipper)
    {
        $this->user = auth()
            ->guard('api')
            ->user();
        $this->zipper = $zipper;
    }

    public function index(Request $request)
    {
        $projects = Project::query();
        if (!$this->user->isAdmin()) {
            $projects = $projects->where('client_id', $this->user->id);
        }
        if ($search = $request->get('search')) {
            $projects = $projects->where(function ($q) use ($search) {
                $q->where('code', 'like', "%$search%")
                  ->orWhere('name', 'like', "%$search%");
            });
        }
        $projects = $projects->ordered()
                             ->paginate($request->get('perPage'));
        return $this->withPaginated($projects, new ProjectTransformer());
    }

    public function getProjectsToQuote(Request $request)
    {
        $projects = Project::query()
                           ->where('status', ProjectStatus::IN_REVIEW);
        if ($search = $request->get('search')) {
            $projects = $projects->where(function ($q) use ($search) {
                $q->where('code', 'like', "%$search%")
                  ->orWhere('name', 'like', "%$search%");
            });
        }
        $projects = $projects->ordered()
                             ->paginate($request->get('perPage'));
        return $this->withPaginated($projects, new ProjectTransformer());
    }

    public function show(Project $project)
    {
        return $this->item($project, new ProjectDetailTransformer());
    }

    /**
     * @param CreateProjectRequest $request
     * @return JsonResponse
     */
    public function store(CreateProjectRequest $request)
    {
        DB::beginTransaction();
        try {
            $code = Project::generateNewCode();
            /** @var Project $project */
            $project = Project::query()
                              ->make($request->only([
                                  'name',
                                  'location',
                                  'person_responsible',
                                  'person_responsible_email',
                                  'person_responsible_phone',
                                  'due_date',
                              ]));
            $project->code = $code;
            if ($this->user->isAdmin()) {
                $project->status = ProjectStatus::TODO;
                $project->client()
                        ->associate($request->get('client_id'));
            } else {
                $project->client()
                        ->associate($this->user);
            }
            $project->save();
            $serviceIds = collect($request->get('services'))->pluck('id');
            $project->services()
                    ->sync($serviceIds);

            if ($notes = $request->get('notes')) {
                /** @var ProjectNote $note */
                $note = $project->notes()
                                ->make([
                                    'message' => $notes,
                                ]);
                $note->user()
                     ->associate($this->user);
                $note->save();
            }

            DB::commit();
            return $this->item($project->fresh(), new ProjectDetailTransformer());
        } catch (\Exception $e) {
            DB::rollBack();
            return $this->wrongArguments([
                'message' => $e->getMessage(),
            ]);
        }
    }


    /**
     * @param CreateProjectRequest $request
     * @param Project $project
     * @return JsonResponse
     */
    public function update(CreateProjectRequest $request, Project $project)
    {
        DB::beginTransaction();
        try {
            /** @var Project $project */
            $project->update($request->only([
                'name',
                'location',
                'person_responsible',
                'person_responsible_email',
                'person_responsible_phone',
                'due_date',
            ]));
            $project->save();
            DB::commit();
            return $this->item($project->fresh(), new ProjectDetailTransformer());
        } catch (\Exception $e) {
            DB::rollBack();
            return $this->wrongArguments([
                'message' => $e->getMessage(),
            ]);
        }
    }

    public function destroy(Project $project)
    {
        try {
            $project->delete();
            return response()->json([], 204);
        } catch (\Exception $exception) {
            return $this->wrongArguments([
                'message' => $exception->getMessage(),
            ]);
        }
    }

    public function requestQuotation(Project $project)
    {
        try {
            $result = $project->requestQuotation();
            if ($result) {
                $admin = User::getAdmin();
                $admin->notify(new NotifyAdminForRequestQuotation($project));
            }
            return $this->item($project->fresh(), new ProjectDetailTransformer());
        } catch (\Exception $e) {
            return $this->wrongArguments([
                'message' => $e->getMessage(),
            ]);
        }
    }

    public function respond(Request $request, Project $project)
    {
        try {
            $result = $project->respond($request->get('message'));
            return $this->item($project->fresh(), new ProjectDetailTransformer());
        } catch (\Exception $e) {
            return $this->wrongArguments([
                'message' => $e->getMessage(),
            ]);
        }
    }

    public function getServices(Request $request)
    {
        $clientId = $request->get('clientId');
        $services = Service::query()
                           ->where('is_available', true)
                           ->where(function ($q) use ($clientId) {
                               $q->whereNull('client_id');
                               if ($clientId) {
                                   $q->orWhere('client_id', $clientId);
                               } else {
                                   $q->orWhere('client_id', $this->user->id);
                               }
                           })
                           ->get();
        return $this->collection($services, new ServiceTransformer());
    }

    public function getManagers()
    {
        $managers = User::query()
                        ->where('is_enabled', true)
                        ->whereHas('roles')
                        ->get();
        return $this->collection($managers, new UserTransformer());
    }

    /**
     * @param UploadImageRequest $request
     * @param Project $project
     * @return JsonResponse
     */
    public function uploadLogo(UploadImageRequest $request, Project $project)
    {
        try {
            $project->uploadImage($request->get('image'));
        } catch (\Exception $e) {
            return $this->wrongArguments($e->getMessage());
        }
        return $this->item($project->fresh(), new ProjectDetailTransformer);
    }

    public function uploadDocument(Project $project)
    {
        $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)) {
                $media = $project->addMedia($destination)
                                 ->usingName($fileName)
                                 ->usingFileName("$fileName.$ext")
                                 ->toMediaCollection(Project::DOCUMENTS);
                $media->setCustomProperty('filename', $request->getFileName());
                $media->setCustomProperty('name', $request->getParam('ggName'));
                $media->setCustomProperty('description', $request->getParam('ggDescription'));
                $folderName = $request->getParam('ggFolderName');
                if (!$folderName) {
                    $folderName = $this->user->isAdmin()
                        ? 'Result files'
                        : 'Client files';
                }
                FolderName::query()
                          ->updateOrCreate([
                              'name' => $folderName,
                          ], [
                              'name' => $folderName,
                          ]);
                $media->setCustomProperty('folder_name', $folderName);
                $media->save();
                return $this->item($media->fresh(), new MediaTransformer());
            }
            return response(['message' => 'ok'], 200);
        } catch (\Exception $e) {
            return $this->wrongArguments($e->getMessage());
        }
    }

    public function deleteDocuments(Request $request, Project $project)
    {
        $ids = $request->get('ids');
        $project->deleteMedia($ids);
        return $this->item($project->fresh(), new ProjectDetailTransformer);
    }

    public function downloadDocuments(Request $request, Project $project)
    {
        $ids = $request->get('ids');
        $media = $project->media()
                         ->whereIn('id', $ids)
                         ->get();

        $files = collect();

        /** @var Media $item */
        foreach ($media as $item) {
            $fullUrl = storage_path("app/public/$item->id/$item->file_name");

            if ($content = @file_get_contents($fullUrl)) {
                $realFileName = $item->getCustomProperty('filename');
                $folderName = $item->getCustomProperty('folder_name');
                $path = storage_path("app/tmp/$folderName-$realFileName");
                if (file_put_contents($path, $content)) {
                    $files->push($path);
                }
            }
        }

        if ($files->count() > 0) {
            $zipName = storage_path("app/tmp/GG-{$project->code}.zip");

            $this->zipper->make($zipName)
                         ->add($files->toArray())
                         ->close();

            foreach ($files as $file) {
                @unlink($file);
            }

            return response()
                ->download($zipName)
                ->deleteFileAfterSend(true);
        }

        return response()->json([
            'message' => 'No files found',
        ], 404);
    }

    public function getStatuses()
    {
        $todo = ProjectStatus::TODO;
        $doing = ProjectStatus::DOING;
        $review = ProjectStatus::CLIENT_REVIEW;
        $done = ProjectStatus::DONE;
        return response()->json([
            'data' => [
                [
                    'value' => $todo,
                    'text'  => trans("projectStatus.$todo", [], 'en'),
                ],
                [
                    'value' => $doing,
                    'text'  => trans("projectStatus.$doing", [], 'en'),
                ],
                [
                    'value' => $review,
                    'text'  => trans("projectStatus.$review", [], 'en'),
                ],
                [
                    'value' => $done,
                    'text'  => trans("projectStatus.$done", [], 'en'),
                ],
            ],
        ], 200);
    }

    public function updateStatus(Request $request, Project $project)
    {
        try {
            $project->updateStatus($request->get('status'));
            return $this->item($project, new ProjectTransformer());
        } catch (\Exception $e) {
            return $this->methodForbidden();
        }
    }

    public function getFolderNames()
    {
        $names = FolderName::query()
                           ->orderBy('name', 'asc')
                           ->get();
        return $this->collection($names, new FolderNameTransformer);
    }

}

Zerion Mini Shell 1.0