%PDF- %PDF-
Mini Shell

Mini Shell

Direktori : /var/www/html/hrsys/api/app/Http/Controllers/Api/v1/
Upload File :
Create Path :
Current File : /var/www/html/hrsys/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\BulkAddUsersToProjectRequest;
use App\Http\Requests\Api\v1\Projects\CreateProjectRequest;
use App\Models\BaseModel;
use App\Models\Project;
use App\Models\Role;
use App\Models\User;
use App\Transformers\DayTransformer;
use App\Transformers\ProjectTransformer;
use App\Transformers\UserTransformer;
use Illuminate\Http\Request;
use Throwable;

class ProjectsController extends ApiController
{
    /**
     * @var DayTransformer
     */
    private $transformer;

    public function __construct(ProjectTransformer $transformer)
    {
        $this->transformer = $transformer;
    }

    public function index(Request $request)
    {
        $user = BaseModel::getLoggedInUser();

        $projects = Project::query()
                           ->private($user);
        if ($user->isManager()) {
            $projects = $projects->where('manager_id', $user->id);
        }
        if ($search = $request->get('search')) {
            $projects = $projects->where('code', 'like', "%$search%")
                                 ->orWhere('name', 'like', "%$search%")
                                 ->orWhereHas('client', function ($q) use ($search) {
                                     $q->where('name', 'like', "%$search%");
                                 });

        }
        $projects = $projects->paginate($request->get('per_page'));
        return $this->paginate($projects, $this->transformer);
    }

    public function show($project)
    {
        $user = BaseModel::getLoggedInUser();
        /** @var Project $project */
        $project = Project::query()
                          ->findOrFail($project);
        if ($project->is_private && $user->id !== $project->manager_id) {
            return $this->unauthorized([
                'message' => trans('auth.unauthorized'),
            ]);
        }
        if (!$user->isAdmin() && $project->manager_id !== $user->id) {
            return $this->notFound([
                'message' => trans('projects.restricted_access'),
            ]);
        }
        return $this->item($project, $this->transformer);
    }

    public function store(CreateProjectRequest $request)
    {
        try {
            $project = Project::createItem($request->only([
                'code',
                'name',
                'start_date',
                'end_date',
                'estimation',
                'price',
                'currency',
                'notes',
                'client_id',
                'manager_id',
            ]));
            return $this->item($project, $this->transformer);
        } catch (Throwable $e) {
            return $this->wrongArguments([
                'message' => $e->getMessage(),
            ]);
        }
    }

    public function update(CreateProjectRequest $request, $project)
    {
        try {
            /** @var Project $project */
            $project = Project::query()
                              ->findOrFail($project);
            $user = BaseModel::getLoggedInUser();
            if (!$user->isAdmin() && $project->manager_id !== $user->id) {
                return $this->notFound([
                    'message' => trans('projects.restricted_access'),
                ]);
            }
            if ($project->is_private && $user->id !== $project->manager_id) {
                return $this->unauthorized([
                    'message' => trans('auth.unauthorized'),
                ]);
            }
            $project->updateItem($request->only([
                'code',
                'name',
                'start_date',
                'end_date',
                'estimation',
                'price',
                'currency',
                'notes',
                'client_id',
                'manager_id',
            ]));
            return $this->item($project, $this->transformer);
        } catch (Throwable $e) {
            return $this->wrongArguments([
                'message' => $e->getMessage(),
            ]);
        }
    }

    public function destroy(Project $project)
    {
        $user = BaseModel::getLoggedInUser();
        if (!$user->isAdmin() && $project->manager_id !== $user->id) {
            return $this->notFound([
                'message' => trans('projects.restricted_access'),
            ]);
        }
        if ($project->timecards()
                    ->count() > 0) {
            return $this->wrongArguments([
                'message' => trans('projects./'),
            ]);
        }
        if ($project->users()
                    ->count() > 0) {
            return $this->wrongArguments([
                'message' => trans('projects.cant_delete_due_users'),
            ]);
        }
        if ($project->is_private && $user->id !== $project->manager_id) {
            return $this->unauthorized([
                'message' => trans('auth.unauthorized'),
            ]);
        }
        Project::destroy($project->id);
        return $this->noContent();
    }

    public function currencies()
    {
        return response()->json([
            Project::EURO,
            Project::ALL,
            Project::USD,
        ], 200);
    }

    public function getUsers(Project $project)
    {
        return $this->collection($project->users, new UserTransformer(), 'users');
    }

    public function addUser(Project $project, User $user)
    {
        $loggedUser = BaseModel::getLoggedInUser();
        if (!$loggedUser->isAdmin() && $project->manager_id !== $loggedUser->id) {
            return $this->notFound([
                'message' => trans('projects.restricted_access'),
            ]);
        }
        try {
            if (!$user->hasProjectAccess($project->id)) {
                $user->projects()
                     ->attach($project);
            }
            return $this->item($project, $this->transformer);
        } catch (Throwable $e) {
            return $this->wrongArguments([
                'message' => $e->getMessage(),
            ]);
        }
    }

    public function bulkAddUsers(BulkAddUsersToProjectRequest $request, Project $project)
    {
        $loggedUser = BaseModel::getLoggedInUser();
        if (!$loggedUser->isAdmin() && $project->manager_id !== $loggedUser->id) {
            return $this->notFound([
                'message' => trans('projects.restricted_access'),
            ]);
        }
        try {
            $userIds = $request->get('ids');
            $users = User::query()
                         ->whereIn('id', $userIds)
                         ->get();
            foreach ($users as $user) {
                if (!$user->hasProjectAccess($project->id)) {
                    $user->projects()
                         ->attach($project);
                }
            }
            return $this->item($project, $this->transformer);
        } catch (Throwable $e) {
            return $this->wrongArguments([
                'message' => $e->getMessage(),
            ]);
        }
    }

    public function removeUser(Project $project, User $user)
    {
        $loggedUser = BaseModel::getLoggedInUser();
        if (!$loggedUser->isAdmin() && $project->manager_id !== $loggedUser->id) {
            return $this->notFound([
                'message' => trans('projects.restricted_access'),
            ]);
        }
        try {
            $user->projects()
                 ->detach($project);
            return $this->item($project, $this->transformer);
        } catch (Throwable $e) {
            return $this->wrongArguments([
                'message' => $e->getMessage(),
            ]);
        }
    }

    public function myProjects()
    {
        $user = BaseModel::getLoggedInUser();
        $projects = Project::query()
                           ->where('manager_id', $user->id)
                           ->orWhereHas('users', function ($q) use ($user) {
                               $q->where('user_id', $user->id);
                           })
                           ->get();
        return $this->collection($projects, $this->transformer);
    }

    public function performance(Request $request, Project $project)
    {
        return $project->performance();
    }

    public function getManagers()
    {
        $users = User::query()
                     ->where('is_enabled', true)
                     ->whereHas('roles', function ($q) {
                         $q->whereIn('name', [
                             Role::ADMIN,
                             Role::MANAGER,
                         ]);
                     })
                     ->get();
        return $this->collection($users, new UserTransformer());
    }

}

Zerion Mini Shell 1.0