Server : Apache System : Linux server2.corals.io 4.18.0-348.2.1.el8_5.x86_64 #1 SMP Mon Nov 15 09:17:08 EST 2021 x86_64 User : corals ( 1002) PHP Version : 7.4.33 Disable Function : exec,passthru,shell_exec,system Directory :  /home/corals/job-board.corals.io/Corals/modules/Jobs/Classes/

Upload File : current_dir [ Writeable ] document_root [ Writeable ]

<?php

namespace Corals\Modules\Jobs\Classes;

use Corals\Modules\Jobs\Models\Job;
use Corals\Modules\Jobs\Models\JobApplication;
use Corals\Modules\Utility\Facades\Category\Category;
use Corals\Modules\Utility\Facades\ListOfValue\ListOfValues;
use Corals\Settings\Facades\Settings;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;


class Jobs
{
    public $page_limit;

    /**
     * Foo constructor.
     */
    function __construct()
    {
        $this->page_limit = Settings::get('jobs_appearance_page_limit', 10);
    }

    /**
     * @param Job $job
     * @return mixed
     */
    public function getSchedules(Job $job, $availableOnly = false)
    {
        $schedule = $job->schedule;
        if (!$availableOnly) {
            return $schedule;
        }

        $availableSchedule = [];

        foreach ($schedule as $record) {
            $recordAvailableSlots = [];
            $date = data_get($record, 'date');
            $recordAvailableSlots['date'] = $date;
            $recordAvailableSlots['times'] = [];
            foreach (data_get($record, 'times') as $time) {
                if (!JobApplication::where([
                    ['job_id', '=', $job->id],
                    ['schedule_date', '=', $date],
                    ['schedule_time', '=', $time]
                ])->exists()) {
                    $recordAvailableSlots['times'] [] = $time;
                }
            }

            $availableSchedule[] = $recordAvailableSlots;
        }

        return $availableSchedule;
    }


    public function getCategories($isFeatured = false)
    {
        $result = Category::getCategoriesList('Jobs', false, true, 'active', [], $isFeatured);
        return $result;
    }

    public function getCategoryJobsCount($category)
    {
        $result = DB::table('utility_model_has_category')->where('category_id', '=', $category->id)
            ->join('jo_jobs', 'jo_jobs.id', '=', 'utility_model_has_category.model_id')
            ->where('jo_jobs.status', '=', 'published')
            ->where('utility_model_has_category.model_type', '=', getMorphAlias(Job::class))
            ->count();

        return $result;
    }


    public function getJobPerCategory()
    {
        $jobs = Job::published()->with('categories')->latest('id')->take(20)->get();

        $categories = [];

        foreach ($jobs as $job) {
            foreach ($job->categories as $category) {
                if (!isset($categories[$category->id])) {
                    $categories[$category->id] = [
                        'category' => $category,
                        'jobs' => []
                    ];
                }

                $categories[$category->id]['jobs'][] = $job;
            }
        }
        return $categories;
    }

    protected function jobsBaseQuery()
    {
        return Job::published();
    }

    public function getJobList(Request $request)
    {
        $jobs = $this->jobsBaseQuery();

        foreach ($request->all() as $filter => $value) {
            $filterMethod = $filter . 'QueryBuilderFilter';
            if (method_exists($this, $filterMethod) && !empty($value)) {
                $jobs = $this->{$filterMethod}($jobs, $value);
            }
        }

        return $jobs->select('jo_jobs.*')->paginate($this->page_limit);
    }

    protected function searchQueryBuilderFilter($jobs, $search_term)
    {
        $jobs = $jobs->where('title', '=', $search_term);
        return $jobs;
    }

    protected function categoryQueryBuilderFilter($jobs, $categorySlug)
    {
        $queryMethod = 'where';

        if (is_array($categorySlug)) {
            $queryMethod = 'whereIn';
        }

        $jobs = $jobs->whereHas('activeCategories', function (Builder $query) use ($categorySlug, $queryMethod) {
            $query->{$queryMethod}('slug', $categorySlug);
        });

        return $jobs;
    }

    protected function job_typeQueryBuilderFilter($jobs, $job_type)
    {
        $queryMethod = 'where';

        if (is_array($job_type)) {
            $queryMethod = 'whereIn';
        }

        $jobs = $jobs->{$queryMethod}('job_type', $job_type);
        return $jobs;
    }

    protected function experience_levelQueryBuilderFilter($jobs, $experience_level)
    {
        $queryMethod = 'where';

        if (is_array($experience_level)) {
            $queryMethod = 'whereIn';
        }
        $jobs = $jobs->{$queryMethod}('experience_level', $experience_level);

        return $jobs;
    }

    protected function locationQueryBuilderFilter($jobs, $location)
    {
        $jobs = $jobs->whereHas('location', function (Builder $query) use ($location) {
            $query->where('slug', $location);
        });
        return $jobs;
    }

    protected function sortQueryBuilderFilter($jobs, $sortOption)
    {
        switch ($sortOption) {
            case 'a_z_order':
                $jobs = $jobs->orderBy('jo_jobs.title', 'asc');
                break;
            case 'z_a_order':
                $jobs = $jobs->orderBy('jo_jobs.title', 'desc');
                break;
        }
        return $jobs;
    }


    public function getJobType()
    {
        return ListOfValues::get('job-types');
    }

    public function getJobTypeCount($jobType)
    {
        return DB::table('jo_jobs')->where([
            ['job_type', '=', $jobType],
            ['status', '=', 'published']
        ])->count();
    }

    public function getExperienceLevel()
    {
        return ListOfValues::get('experience-level');
    }

    public function getExperienceLevelCount($experienceLevel)
    {
        return DB::table('jo_jobs')->where([
            ['experience_level', '=', $experienceLevel],
            ['status', '=', 'published']
        ])->count();
    }

    public function checkActiveKey($value, $compareWithKey)
    {
        if (request()->has($compareWithKey)) {
            $compareWithValue = request()->get($compareWithKey);

            if (is_array($compareWithValue)) {
                return array_search($value, $compareWithValue) !== false;
            } else {
                return $value == $compareWithValue;
            }
        }

        return false;
    }

    protected function jobApplicationsBaseQuery()
    {
        return JobApplication::myjobapplications();
    }

    public function getJobApplications(Request $request)
    {
        $jobApplications = $this->jobApplicationsBaseQuery();

        foreach ($request->all() as $filter => $value) {
            $filterMethod = $filter . 'ApplicationsQueryBuilderFilter';
            if (method_exists($this, $filterMethod) && !empty($value)) {
                $jobApplications = $this->{$filterMethod}($jobApplications, $value);
            }
        }

        return $jobApplications->select('jo_job_applications.*')->paginate($this->page_limit);
    }

    protected function jobApplicationsEmployerBaseQuery(Job $job)
    {
        return JobApplication::myjobapplicationsEmployer($job);
    }

    public function getJobApplicationsEmployer(Request $request, Job $job)
    {
        $jobApplications = $this->jobApplicationsEmployerBaseQuery($job);

        foreach ($request->all() as $filter => $value) {
            $filterMethod = $filter . 'ApplicationsQueryBuilderFilter';
            if (method_exists($this, $filterMethod) && !empty($value)) {
                $jobApplications = $this->{$filterMethod}($jobApplications, $value);
            }
        }

        return $jobApplications->select('jo_job_applications.*')->paginate($this->page_limit);
    }

    protected function searchApplicationsQueryBuilderFilter($jobApplications, $search_term)
    {
        $jobApplications = $jobApplications->whereHas('job', function (Builder $query) use ($search_term) {
            $query->where('title', $search_term);
        });

        return $jobApplications;
    }


    public function jobsCount($excludedStatuses = ['draft'])
    {
        return Job::query()
            ->when($excludedStatuses, function ($statusQB, $excludedStatuses) {
                $statusQB->whereNotIn('status', $excludedStatuses);
            })->count();
    }

    public function jobApplicationCount($job)
    {
        return $this->jobApplicationsEmployerBaseQuery($job)->count();
    }

    public function getMyJobs(Request $request, $count = false)
    {
        $employer = \Corals\Modules\Jobs\Facades\Employers::getMyEmployer();

        $jobs = Job::query()->where('owner_id', $employer->id);

        foreach ($request->all() as $filter => $value) {
            $filterMethod = $filter . 'QueryBuilderFilter';
            if (method_exists($this, $filterMethod) && !empty($value)) {
                $jobs = $this->{$filterMethod}($jobs, $value);
            }
        }

        if ($count) {
            return $jobs->count();
        } else {
            return $jobs->select('jo_jobs.*')->paginate($this->page_limit);
        }
    }

}