8889841cPK     ¨|[óZMï~
  ~
    DispatchJobController.phpnu „[µü¤        <?php

namespace App\Http\Controllers;

use App\Models\Client;
use App\Models\CustomDispatchJob;
use App\Models\DispatchJob;
use App\Models\DocumentDispatchJob;
use App\Models\RecieveDoc;
use Barryvdh\DomPDF\PDF;
use Illuminate\Http\Request;

class DispatchJobController extends Controller
{
    public function listdispatch()
    {
        $dispatch = DocumentDispatchJob::all();
        return view('dispatch.dispatchdoc', compact('dispatch'));
    }
    public function dispCreate()
    {
        $clients = Client::all();
        $DocsReceived = RecieveDoc::with('clientRecieveDoc')->get();
        return view('dispatch.createDispatch', compact('DocsReceived', 'clients'));
    }
    public function customDispatchCreate()
    {
        $custdispatch = CustomDispatchJob::all();
        return view('dispatch.customDispatchlist', compact('custdispatch'));
    }
    public function storedispatch(Request $request)
    {
        $dispatchdata = new DispatchJob();

        $dispatchdata->clients_id        =  $request->selected_client;
        $dispatchdata->dispatch_date     =  $request->dispatch_date;
        $dispatchdata->date_received     =  $request->date_doc_receive;
        $dispatchdata->description       =  $request->disp_doc_desc;
        $dispatchdata->Qty               =  $request->disp_doc_qty;
        $dispatchdata->checkout          =  $request->disp_doc_chckout;
        $dispatchdata->narration         =  $request->disp_doc_narration;
        $dispatchdata->custom_desc       =  $request->custom_desc;
        $dispatchdata->custom_check      =  $request->custom_check;
        $dispatchdata->custom_narration  =  $request->custom_narration;
        $dispatchdata->dispatch_note     =  $request->dispatch_note;
        $dispatchdata->dispatchCreator   =  $request->dispatchCreator;

        $dispatchdata->save();
        return view('dispatch.dispatchdoc');
    }
    public function viewdispatch($id)
    {
        # code...
    }
    public function DocsReceive(Request $request)
    {
        $docReceived = RecieveDoc::where('client_id', '=', $request->id)->get();
        if (count($docReceived) > 0) {
            return response()->json($docReceived);
        }
    }
    public function DispatchClient(Request $request)
    {
        $clientAddress = Client::where('id', '=', $request->id)->get();
        if (count($clientAddress) > 0) {
            return response()->json($clientAddress);
        }
    }
    public function dispCreateCustom()
    {
        $clients = Client::all();
        $DocsReceived = RecieveDoc::with('clientRecieveDoc')->get();
        return view('dispatch.customDispatch', compact('DocsReceived', 'clients'));
    }
}
PK     ¨|[fdê      ClientsServiceController.phpnu „[µü¤        <?php

namespace App\Http\Controllers;

use App\Models\ClientsService;
use App\Models\Service;
use Carbon\Carbon;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;

class ClientsServiceController extends Controller
{

    public function assignService(Request $request)
    {
        //$assignservice = new ClientsService();
        //$assignservice->services_id = $request->assignservice;
        //$assignservice->save();

    }
    public function getAssignedService(Request $request)
    {
        /* $service = DB::table('client_services')
            ->join('services', 'client_services.services_id', '=', 'services.id')
            ->select('services.*')
            ->where('client_services.clients_id', $request->clients_id)
            ->where('status', 'Active')
            ->get();*/

        /*$service = Service::join('client_services', 'client_services.services_id', '=', 'services.id')
            ->where('client_services.clients_id', $request->clients_id)
            ->where('status', 'Active')
            ->get();*/

        $service = ClientsService::with('service')
            ->where('clients_id', $request->clients_id)
            ->get();

        if (count($service) > 0) {
            return response()->json($service);
        }
    }
    public function assignServiceUpdate($id)
    {
        $assignservice = ClientsService::find($id);
        return view('client.assignedService.assignservice', compact('assignservice'));
    }
    public function assignServiceUpdateData(Request $request, $id)
    {
        $data = ClientsService::find($id);
        $schedule_end = $request->enddate;
        $start_date = Carbon::parse($data->created_at)->format('Y-m-d');

        if ($schedule_end > $start_date) {
            $data->update([
                'schedule_end' => $schedule_end
            ]);
            return redirect()->back()->with('message', 'End date is Successfully updated!');
        } else {
            return back()->with('error', 'End date must be greater than start date!');
        }
    }
}
PK     ¨|[qÓïžÇ
  Ç
    TemplateController.phpnu „[µü¤        <?php

namespace App\Http\Controllers;

use App\Models\Template;
use Illuminate\Support\Facades\DB;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Storage;

class TemplateController extends Controller
{
    public function template()
    {
        $templates = Template::all();
        $files     = Storage::files('public/uploads');
        foreach ($files as $file)
            return view('template.template', compact('templates', 'file'));
    }
    public function newTemplate()
    {
        return view('template.createtemplate');
    }
    public function store(Request $request)
    {
        $request->validate([
            'file' => 'required|file|mimes:pdf|max:2048',
        ]);

        try {
            $filepdf = $request->file('file');
            if ($filepdf->isValid()) {
                $fileName = uniqid() . '.' . $filepdf->getClientOriginalExtension();
                $filepdf->storeAs('public/template', $fileName);

                $template = new Template();
                $template->name = $request->name;
                $template->description = $request->description;
                $template->is_new = true;
                $template->file = $fileName;
                $template->save();

                return redirect()->back()->with('message', 'Template created successfully.');
            }
        } catch (\Exception $e) {
            return redirect()->back()->withInput()->withErrors(['file' => 'An error occurred: ' . $e->getMessage()]);
        }

        /*$filepdf = $request->file('file');
        if ($filepdf->isValid()) {
            $fileName = uniqid() . '.' . $filepdf->getClientOriginalExtension();
            $filepdf->storeAs('public/template', $fileName);

            $template = new Template();
            $template->name = $request->name;
            $template->description = $request->description;
            $template->is_new = true;
            $template->file = $fileName;
            $template->save();

            return redirect()->back()->with('message', 'Template created successfully.');
        } else {
            return redirect()->back()->withInput()->withErrors(['file' => 'Invalid file uploaded.']);
        }*/
    }
    public function templateBadge()
    {
        $temp = Template::where('is_new', true)->orderBy('created_at', 'desc')->first();
    }
    public function DeleteTemplate($id)
    {
        $temp = Template::find($id);
        if (!empty($temp)) {
            Storage::delete('/public/template/' . $temp->file);
            $temp->delete();
            return redirect()->back()->with('message', 'Template deleted successfully!');
        } else {
            return redirect()->back()->with('error', "No template found!");
        }
    }
}
PK     ¨|[w¥Ät  t    PortalPasswrdController.phpnu „[µü¤        <?php

namespace App\Http\Controllers;

use App\Models\Client;
use App\Models\portalpassword;
use Illuminate\Http\Request;

class PortalPasswrdController extends Controller
{
    public function companyFormation($id)
    {
        $addClient = Client::find($id);
        return view('client.passwrd', compact('addClient'));
    }
    public function index()
    {
        $addClient = Client::latest('created_at')->first();
        return view('client.passwrd', compact('addClient'));
    }
    public function pwdPortrlForCompFormation()
    {
        return view('client.passwrd');
    }
    public function store(Request $request)
    {

        $pwdportal = new portalpassword();
        $pwdportal->client_id          =   $request->clientId;
        $pwdportal->tra_portal_name    =   $request->tra_portal_name;
        $pwdportal->tra_portal_tin     =   $request->tra_portal_tin;
        $pwdportal->tax_portal_passwrd =   $request->tax_portal_passwrd;
        $pwdportal->tax_portal_tin     =   $request->tax_portal_tin;
        $pwdportal->payment_passwrd    =   $request->payment_passwrd;
        //$pwdportal->brela_name         =   $request->brela_name;
        $pwdportal->brela_userid       =   $request->brela_userid;
        $pwdportal->brela_passwrd      =   $request->brela_passwrd;
        $pwdportal->nssf_userid        =   $request->nssf_userid;
        $pwdportal->nssf_passwrd       =   $request->nssf_passwrd;
        $pwdportal->efin_userid        =   $request->efin_userid;
        $pwdportal->efin_passwrd       =   $request->efin_passwrd;
        $pwdportal->wcf_name           =   $request->wcf_name;
        $pwdportal->wcf_userid         =   $request->wcf_userid;
        $pwdportal->wcf_passwrd        =   $request->wcf_passwrd;
        //$pwdportal->wcf_ic_name        =   $request->wcf_ic_name;
        $pwdportal->wcf_ic_userid      =   $request->wcf_ic_userid;
        $pwdportal->wcf_ic_passwrd     =   $request->wcf_ic_passwrd;
        $pwdportal->bo_name            =   $request->bo_name;
        $pwdportal->bo_userid          =   $request->lasbo_useridtId;
        $pwdportal->bo_passwrd         =   $request->bo_passwrd;

        $pwdportal->save();
        return redirect()->route('client.clients');
    }
    public function updateview($id)
    {
        $pwdupdate = portalpassword::where('client_id', $id)->first();

        if (empty($pwdupdate)) {
            $addClient = Client::find($id);
            return view('client.passwrd', compact('addClient'));
        } else {
            return view('client.passwrdupdate', compact('pwdupdate'));
        }
    }
    public function updatedate()
    {
        return view();
    }
    public function updatePwPortral(Request $request, $id)
    {

        $pwPortal = portalpassword::find($id);
        $pwPortal->update($request->all());
        return redirect()->back()->with('message', 'Password are updated successfully!');
    }
}
PK     ¨|[BÍ‹­Í  Í    HrmController.phpnu „[µü¤        <?php

namespace App\Http\Controllers;

use App\Models\Attendance;
use App\Models\CheckInTime;
use App\Models\CheckOutTime;
use App\Models\LeaveRequest;
use App\Models\User;
use DateTime;
use Illuminate\Auth\Events\Validated;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;

class HrmController extends Controller
{
    public function attendanceIndex()
    {
        $employees = User::all();
        return view('hrm.attendance', compact('employees'));
    }
    public function attendanceList()
    {
        $result = Attendance::with('employeeAtt')->get();
        //$checkin = CheckInTime::with('employeeAtt')->get();
        //$checkout = CheckOutTime::with('employeeAtt')->get();
        $attendance = CheckInTime::with(['employeeAtt', 'checkOutTime'])
            ->get();
        //return response()->json($result);
        return view('hrm.attendancelist', compact('attendance'));
    }
    public function leaveRequestIndex()
    {
        return view('hrm.leaverequest');
    }
    public function leaveRequestData(Request $request)
    {
        $newRequest = $request->validate([
            'userId'  => 'required',
            'dateFrom' => 'required',
            'dateTo'   => 'required',
            'requestType' => 'required'
        ]);

        LeaveRequest::create([
            'user_id'      => Auth::user()->id,
            'dateFrom'     => $request->dateFrom,
            'dateTo'       => $request->dateTo,
            'request_type' => $request->requestType,
            //'status'     => 'Active',
        ]);
        return redirect()->back()->with('message', 'Request sent successfully! Wait for approval from the admin.');

        //return response()->json($newRequest);
    }

    public function leaveRequestList()
    {
        //$reqLeave = LeaveRequest::where('request_type', 'Annual')->get();
        $req = LeaveRequest::all();
        //$req = LeaveRequest::with('userRequest')->get();
        return view('hrm.requestlist', compact('req'));
    }

    public function RequestListEmployee()
    {
        $id = Auth::user()->id;
        $requests = LeaveRequest::where('user_id', '=', $id)->get();
        return view('hrm.requestlistemployee', compact('requests'));
    }
    public function leaveRequestApproval($id)
    {
        $leave = LeaveRequest::find($id);
        $leave->status = 'Approved';
        $leave->update();

        return redirect()->back()->with('message', 'Request approved successfully!');
    }
    public function leaveRequestDenied($id)
    {
        $leave = LeaveRequest::find($id);
        $leave->status = 'Disapproved';
        $leave->update();

        return redirect()->back()->with('message', 'Request approved successfully!');
    }
    public function ChechInTime(Request $request)
    {
        $checkin = new CheckInTime();
        $checkin->chechin_time = $request->checkintime;
        $checkin->checkin_date = $request->checkindate;
        $checkin->user_id      = $request->employee;


        return redirect()->back()->with('message', 'Attendance added successfully!');
    }
    public function CreateAttendencaList(Request $request)
    {
        $employees = User::all();
        return view('hrm.attendancecreate', compact('employees'));
    }
    public function CreateAttendenceForm(Request $request)
    {
        /* $attandenceData = $request->all();
        //$attendanceDate = $request->attandaceDate;

        $count = count($attandenceData['userId']);
        for ($i = 0; $i < $count; $i++) {
            Attendance::create([
                'user_id' => $attandenceData['userId'][$i],
                'checked_in_time' => $attandenceData['timeIn'][$i],
                'checked_out_time' => $attandenceData['timeOut'][$i],
                'attendance_date' => $attandenceData['attandaceDate'],
            ]);
        }
        return redirect()->back()->with('message', 'Attendance Added Successfully!');*/
        $request->validate([
            'attandaceDate' => 'required|date',
            'timeIn.*' => 'required|date_format:h:i A',
            'timeOut.*' => 'required|date_format:h:i A',
        ]);

        // Retrieve the attendance date
        $attendanceDate = $request->input('attandaceDate');

        // Retrieve the user IDs, timeIn, and timeOut arrays
        $userIds = $request->input('userId');
        $timeIn = $request->input('timeIn');
        $timeOut = $request->input('timeOut');

        // Loop through each user and save their attendance
        foreach ($userIds as $key => $userId) {
            Attendance::create([
                'user_id' => $userId,
                'checked_in_time' => $timeIn[$key],
                'checked_out_time' => $timeOut[$key],
                'attendance_date' => $attendanceDate,
            ]);
        }
    }
}
PK     ¨|[§5Þ  Þ    PusherController.phpnu „[µü¤        <?php

namespace App\Http\Controllers;

use App\Events\messageEvent;
use Illuminate\Http\Request;
use App\Events\PusherBroadcast;
use Illuminate\Broadcasting\Broadcasters\PusherBroadcaster;

class PusherController extends Controller
{
    public function index()
    {
        return view('chat.index');
    }
    public function broadcast(Request $request)
    {
        //broadcast(new PusherBroadcast($request->get('message')))->toOthers();

        //event(new messageEvent($request->get('message')));
        // return view('chat.broadcast', ['message' => $request->get('message')]);
    }

    public function receive(Request $request)
    {
        return view('chat.receive', ['message' => $request->get('message')]);
    }
}
PK     ¨|[tîŽ  Ž    Controller.phpnu „[µü¤        <?php

namespace App\Http\Controllers;

use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
use Illuminate\Foundation\Bus\DispatchesJobs;
use Illuminate\Foundation\Validation\ValidatesRequests;
use Illuminate\Support\Facades\Auth;
use Illuminate\Routing\Controller as BaseController;

class Controller extends BaseController
{
    use AuthorizesRequests, DispatchesJobs, ValidatesRequests;
}
PK     ¨|[í8>Ø  Ø    PolicyController.phpnu „[µü¤        <?php

namespace App\Http\Controllers;

use App\Models\Policies;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Storage;

class PolicyController extends Controller
{
    public function displayPolicy()
    {
        $policies = Policies::all();
        return view('policies.policies', compact('policies'));
    }

    public function createPolicy(Request $request)
    {
        $policy = new Policies();

        $policy->policy_name = $request->policy_name;
        if ($request->hasFile('file')) {
            $file      = $request->file('file');
            $fileName  = uniqid() . '.' . $file->getClientOriginalExtension();
            $file->storeAs('public/policyfile', $fileName);
        }
        $policy->file =  $fileName;

        $policy->save();
        return redirect()->route('policies.policies')->with('message', 'Successfuly new policy added');
    }
    public function createNewPolicy()
    {
        return view('policies.create_policy');
    }
}
PK     ¨|[ÌÛ=Î+   +     ServiceController.phpnu „[µü¤        <?php

namespace App\Http\Controllers;

use App\Models\Postchecks;
use App\Models\Prechecks;
use App\Models\Service;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;

class ServiceController extends Controller
{
    public function services()
    {
        $services = DB::table('services')->orderby('created_at')->get();
        return view('service.services', ['services' => $services]);
    }
    public function view($id)
    {
        $checklistData = DB::table('service_postchecks')
            ->join('service_prechecks', 'service_postchecks.id', '=', 'service_prechecks.id')
            ->where('service_postchecks.service_id', '=', $id)
            ->get();

        $preData = Prechecks::where('service_id', '=', $id)->get();
        $postData = Postchecks::where('service_id', '=', $id)->get();
        $service = Service::find($id);
        return view('service.viewService', ['service' => $service, 'postData' => $postData, 'preData' => $preData]);
    }

    public function store(Request $request)
    {
        $clientservice = new Service();

        $clientservice->service_name               =    $request->service_name;
        $clientservice->description                =    $request->description;
        $clientservice->category                   =    $request->category;
        $clientservice->duedate                    =    $request->duedate;
        $clientservice->role                       =    $request->role;
        $clientservice->repeat                     =    $request->repeat;
        $clientservice->service_kpi                =    $request->service_kpi;
        $clientservice->kpi_receive_target_day     =    $request->kpi_receive_target_day;
        $clientservice->kpi_receive_early_points   =    $request->kpi_receive_early_points;
        $clientservice->kpi_receive_late_points    =    $request->kpi_receive_late_points;
        $clientservice->kpi_complete_target_day    =    $request->kpi_complete_target_day;
        $clientservice->kpi_complete_early_points  =    $request->kpi_complete_early_points;
        $clientservice->kpi_complete_late_points   =    $request->kpi_complete_late_points;

        $clientservice->save();
        //redirect the user
        return redirect()->route('service.services')->with('message', 'Service created successfully!');
    }

    public function createServices()
    {
        return view('service.servicesCreate');
    }
    public function edit($id)
    {
        $service = Service::find($id);
        return view('service.editService', compact('service'));
    }
    /*public function storeupdate(Request $request, $id)
    {
        $serviceupdate = Service::find($id);

        $serviceupdate->service_name               =    $request->service_name;
        $serviceupdate->description                =    $request->description;
        $serviceupdate->category                   =    $request->category;
        $serviceupdate->duedate                    =    $request->duedate;
        $serviceupdate->role                       =    $request->role;
        $serviceupdate->repeat                     =    $request->repeat;
        $serviceupdate->service_kpi                =    $request->service_kpi;
        $serviceupdate->kpi_receive_target_day     =    $request->kpi_receive_target_day;
        $serviceupdate->kpi_receive_early_points   =    $request->kpi_receive_early_points;
        $serviceupdate->kpi_receive_late_points    =    $request->kpi_receive_late_points;
        $serviceupdate->kpi_complete_target_day    =    $request->kpi_complete_target_day;
        $serviceupdate->kpi_complete_early_points  =    $request->kpi_complete_early_points;
        $serviceupdate->kpi_complete_late_points   =    $request->kpi_complete_late_points;

        $serviceupdate->update();
        return redirect()->back()->with('message', 'Changes are added successfully!');
    }*/
    public function storeupdate(Request $request, $id)
    {
        /*$request->validate([
            'service_name' => 'required|string|max:255',
            'category' => 'required|string',
            'duedate' => 'nullable|numeric',
            'role' => 'required|string',
            'repeat' => 'required|string',
            'service_kpi' => 'required|string',
            'kpi_complete_target_day' => 'nullable|numeric',
            'kpi_complete_early_points' => 'nullable|numeric',
            'kpi_complete_late_points' => 'nullable|numeric',
        ]);*/

        try {
            $service = Service::findOrFail($id);

            $service->service_name = $request->service_name;
            $service->category = $request->category;
            $service->duedate = $request->duedate;
            $service->role = $request->role;
            $service->repeat = $request->repeat;
            $service->service_kpi = $request->service_kpi;
            $service->kpi_complete_target_day = $request->kpi_complete_target_day;
            $service->kpi_complete_early_points = $request->kpi_complete_early_points;
            $service->kpi_complete_late_points = $request->kpi_complete_late_points;

            $service->save();

            return redirect()->back()->with('success', 'Service updated successfully.');
        } catch (\Exception $e) {
            return redirect()->back()->with('error', 'Failed to update service. ' . $e->getMessage());
        }
    }


    public function delete($id)
    {
        $service = Service::find($id);
        if (!$service) {
            return redirect()->back()->with('error', 'Service not found!');
        }
        $service->delete();
        return redirect()->back()->with('message', 'Service has been deleted successfully!');
    }

    public function checklistView($id)
    {
        $service = Service::find($id);
        $checklistData = DB::table('service_postchecks')
            ->join('service_prechecks', 'service_postchecks.id', '=', 'service_prechecks.id')
            ->where('service_postchecks.service_id', '=', $id)
            ->get();

        $preData = Prechecks::where('service_id', '=', $id)->get();
        $postData = Postchecks::where('service_id', '=', $id)->get();
        return view('service.checklist', compact('service', 'preData', 'postData'));
    }

    public function checkList(Request $request)
    {
        $formData = $request->all();

        foreach ($formData['name'] as $index => $name) {
            if ($name == "PreCheck") {
                Prechecks::create([
                    'service_id'       => $formData['service_id'],
                    'name'             => $name,
                    'note'             => $formData['note'][$index],
                    'multiple_upload'  => $formData['multiple_upload'][$index],
                    'mandatory'        => $formData['mandatory'][$index],
                    'description'      => $formData['description'][$index],
                ]);
            } elseif ($name == "PostCheck") {
                Postchecks::create([
                    'service_id'        => $formData['service_id'],
                    'name'              => $name,
                    'note'              => $formData['note'][$index],
                    'multiple_upload'   => $formData['multiple_upload'][$index],
                    'mandatory'         => $formData['mandatory'][$index],
                    'description'       => $formData['description'][$index],
                ]);
            }
        }
        return redirect()->back()->with('message', 'Checklist are added successfully!');
    }
    public function precheckListDelete($id)
    {
        $checklist = Prechecks::find($id);

        if (!$checklist) {
            return redirect()->back()->with('error', 'Checklist not found!');
        }
        $checklist->delete();
        return redirect()->back()->with('message', 'Checklist has been deleted successfully!');
    }
    public function postcheckListDelete($id)
    {
        $checklist = Postchecks::find($id);

        if (!$checklist) {
            return redirect()->back()->with('error', 'Checklist not found!');
        }
        $checklist->delete();
        return redirect()->back()->with('message', 'Checklist has been deleted successfully!');
    }
}
PK     ¨|[5Ô–ˆ;  ;    GeneralSettingController.phpnu „[µü¤        <?php

namespace App\Http\Controllers;

use App\Models\GeneralSetting;
use Illuminate\Http\Request;

class GeneralSettingController extends Controller
{
    public function general()
    {
        $res = GeneralSetting::latest('updated_at')->get();
        foreach($res as $setting){
            return view('settings.generalsetting', compact('setting'));
        }
    }
    public function store(Request $request){

        $data  = new GeneralSetting();
        $data->site_name  =  $request->site_name;
        $data->phone      =  $request->phone;
        $data->email      =  $request->email;
        $data->logo       =  $request->logo;
        $data->favicon    =  $request->favicon;
        $data->footer     =  $request->footer;
        $data->address    =  $request->address;

        $data->save();
        return redirect()->route('settings.general')->with('message', 'Changes updated successfully.');

    }

    public function updatesetting(Request $request, $id){

       /* if ($request->hasFile('logo')) {
            $logo = $request->file('logo');
            $logoName = 'logo'.'.'.$logo->getClientOriginalExtension();
            $logo->storeAs('public/images', $logoName);
        }

        if ($request->hasFile('favicon')) {
            $favicon = $request->file('favicon');
            $faviconName = 'favicon.ico';
            // Process and save the favicon file
            $favicon->storeAs('public/images', $faviconName);
        }
       $validate  = $request->validate([
            'site_name' => 'required|string|max:250',
            'phone'     =>  'required',
            'email'     =>  'required',
            'logo'      =>  'required|max:2018',
            'favicon'   =>  'required|max:2018',
            'footer'    =>  'required',
            'address'   => 'required',
        ]);

        $data  =  GeneralSetting::find($id);
        $data->site_name        =  $request->site_name;
        $data->phone            =  $request->phone;
        $data->email            =  $request->email;
        $data->logo             =  $logoName;
        $data->favicon          =  $faviconName;
        $data->footer           =  $request->footer;
        $data->address          =  $request->address;

        $data->update();*/
        $validate = $request->validate([
            'site_name' => 'required|string|max:250',
            'phone' => 'required',
            'email' => 'required',
            'logo' => 'required|max:2018',
            'favicon' => 'required|max:2018',
            'footer' => 'required',
            'address' => 'required',
        ]);
        $data = GeneralSetting::find($id);
        // Update the data with the new values
        $data->update([
            'site_name' => $request->site_name,
            'phone' => $request->phone,
            'email' => $request->email,
            'footer' => $request->footer,
            'address' => $request->address,
        ]);

        if ($request->hasFile('logo')) {
            $logo = $request->file('logo');
            $logoName = 'logo.' . $logo->getClientOriginalExtension();
            $logo->storeAs('public/images', $logoName);
            $data->logo = $logoName;
        }

        if ($request->hasFile('favicon')) {
            $favicon = $request->file('favicon');
            $faviconName = 'favicon.ico';
            // Process and save the favicon file
            $favicon->storeAs('public/images', $faviconName);
            $data->favicon = $faviconName;
        }

        $data->update();
        return redirect()->route('settings.general')->with('message', 'Changes updated successfully.');
    }
}
PK     ¨|[Ÿº#í—;  —;    HomeController.phpnu „[µü¤        <?php

namespace App\Http\Controllers;

use App\Models\Client;
use App\Models\Employee;
use App\Models\Role_has_Permission;
use App\Models\Task_Comments;
use App\Models\Task_Post;
use App\Models\Tasks;
use App\Http\Controllers\Storage;
use App\Models\CheckInTime;
use App\Models\CheckOutTime;
use App\Models\KPI_Tracker;
use App\Models\KPIPerfomance;
use Carbon\Carbon;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Storage as FacadesStorage;
use Spatie\Permission\Models\Role;
use Spatie\Permission\Traits\HasPermissions;


class HomeController extends Controller
{
    use HasPermissions;
    /*
    *
     * Create a new controller instance.
     *
     * @return void
     */
    public function __construct()
    {
        $this->middleware('auth');
    }
    /**
     * Show the application dashboard.
     *
     * @return \Illuminate\Contracts\Support\Renderable
     */

    public function kpiTracker()
    {
        $userId = Auth::user()->id;
        $tasks = Tasks::where('user_id', $userId)->get();

        if ($tasks->isEmpty()) {
            return response()->json(['error' => 'No tasks found for this user'], 404);
        }
        foreach ($tasks as $task) {
            if ($task->post_approval === 'yes') {
                continue; // Move to the next task
            }
            $dueDate = Carbon::parse($task->end_date);
            $completionDate = now();
            // Determine KPI points
            if ($completionDate->lt($dueDate)) {
                $kpiPoints = 1;  // Completed before due date
            } elseif ($completionDate->eq($dueDate)) {
                $kpiPoints = 0;  // Completed on due date
            } else {
                $kpiPoints = -1; // Completed after due date
            }

            // Update or create KPI record
            KPIPerfomance::updateOrCreate(
                ['users_id' => $userId, 'tasks_id' => $task->id],
                ['kpi_points' => $kpiPoints, 'updated_at' => now()]
            );
        }

        return response()->json([
            'message' => 'KPI updated successfully for all eligible tasks',
        ]);
    }
    public function index()
    {
        $totalEmployees = Employee::count();
        $totalTask      = Tasks::count();
        $totalClients   = Client::count();
        $roleId         = Auth::user()->role_id;
        $all_perm       = Role::find($roleId)->permissions;
        $role           = Role::find($roleId);
        $comments       = Task_Post::count();
        $userId         =  Auth::user()->id;
        $kpiPoint     = KPIPerfomance::where('users_id', $userId)->pluck('kpi_points')->toArray();
        //$latePoint      = KPI_Tracker::where('users_id', $userId)->pluck('kpi_late_point')->toArray();
        $totalPoint = array_sum($kpiPoint);
        //$totalKpiPoint      = $earlyTotalPoint + $lateTotalPoint;
        //$notifs = $comments->merge($posts);
        /*if ($role->hasPermissionTo('client-view')) {
            echo 'Yes';
        }*/
        if ($roleId === 1) {
            $totalEmployees = Employee::count();
            $totalTask      = Tasks::count();
            $totalClients   = Client::count();
            $roleId = Auth::user()->role_id;
            $all_perm = Role::find($roleId)->permissions;
            $role = Role::find($roleId);
            $comments = Task_Post::count();
            return view('home.index', compact(['totalClients', 'totalEmployees', 'totalTask', 'all_perm', 'comments']))->with('notify', 'hello');
        }
        $currentUser = Auth::user();
        //return response()->json($totalKpiPoint);
        return view('home.employee_dashboard', compact(['totalClients', 'totalEmployees', 'totalTask', 'all_perm', 'comments', 'totalPoint']))->with('notify', 'hello');
    }
    public function services()
    {
        return view('service.services');
    }

    public function servicesCreate()
    {
        return view('service.servicesCreate');
    }

    public function reports()
    {
        return view('month');
    }

    public function settings()
    {
        return view('general');
    }
    public function HeaderNotification() {}
    public function notify_message()
    {
        /*$userId = Auth::User()->id;
        $smsNotify =  Task_Comments::where('user_id',  $userId)->get();
        return view('notifications.messages', compact('smsNotify'));*/
        $userId = Auth::user()->id;
        $smsNotify = Task_Comments::where('user_id', $userId)->get();
        $unreadCount = $smsNotify->where('read', false)->count();
        return response()->json(['unreadCount' => $unreadCount]);
    }
    public function  commentCounter(Request $request)
    {
        $userRole = Auth::user()->role_id;
        $userId  = Auth::user()->id;
        if ($userRole < 2) {
            $count = Task_Comments::count();
            $comm  = Task_Comments::with('commentUser', 'user')
                ->where('user_id', $userId)
                ->orderBy('updated_at', 'asc')
                ->take(50)
                ->get();
            // return response()->json(['count' => $count, 'comm' => $comm]);
            echo $comm->user->profile_image;
        } else {
            $comm  = Task_Comments::with('commentUser', 'user')
                ->where('user_id', $userId)
                ->orderBy('updated_at', 'asc')
                ->take(50)
                ->get();
            $count = Task_Comments::where('user_id', $userId)->count();
            return response()->json(['count' => $count, 'comm' => $comm]);
        }
    }
    public function systemNotification(Request $request)
    {

        $system = Tasks::where('approve_status', '=', 'Approve')
            ->where('suspend_status', '=', 'Suspend')
            ->where('complete_status', '=', 'complete')->get();
        return response()->json($system);
    }

    /*public function notificationUpdate()
    {
        $commentNotify = Task_Comments::with('commentUser')->latest()->take(4)->get();
        $commentCount = Task_Comments::where('is_read', 0)->count();
        $postNotify = Task_Post::with('postuser')->latest()->take(4)->get();
        $postCount = Task_Post::where('is_read', 0)->count();

        return response()->json([
            'commentCount' => $commentCount,
            'comments' => $commentNotify->map(function ($comment) {
                return [
                    'username' => optional($comment->commentUser)->name,
                    'time' => $comment->created_at->diffForHumans(),
                    'comment' => $comment->comments,
                    'avatar' => optional($comment->commentUser)->profile_image
                        ? asset('storage/images/' . optional($comment->commentUser)->profile_image)
                        : asset('storage/images/Avatar.png'),
                ];
            }),
        ]);
    }*/
    public function notificationUpdate()
    {
        $commentCount = Task_Comments::where('is_read', false)->count();
        $commentNotify = Task_Comments::with('commentUser')
            ->where('is_read', false)
            ->latest()
            ->limit(5)
            ->get();

        $postNotify = Task_Post::with('postuser')->latest()->take(5)->get();
        $postCount = Task_Post::where('is_read', false)->count();

        // Format response data for comments
        $formattedComments = $commentNotify->map(function ($comment) {
            return [
                'username' => optional($comment->commentUser)->name ?? 'Unknown User',
                'time' => $comment->created_at->diffForHumans(),
                'taskId' => $comment->task_id,
                'commentId' => $comment->id,
                'comment' => $comment->comments,
                'avatar' => optional($comment->commentUser)->profile_image
                    ? asset('storage/images/' . optional($comment->commentUser)->profile_image)
                    : asset('storage/images/Avatar.png'),
            ];
        });

        // Format response data for posts
        $formattedPosts = $postNotify->map(function ($post) {
            return [
                'username' => optional($post->postuser)->name ?? 'Unknown User',
                'time' => $post->created_at->diffForHumans(),
                'content' => $post->post ?? 'No content available',
                'avatar' => optional($post->postuser)->profile_image
                    ? asset('storage/images/' . optional($post->postuser)->profile_image)
                    : asset('storage/images/Avatar.png'),
            ];
        });

        return response()->json([
            'commentCount' => $commentCount,
            'comments' => $formattedComments,
            'postCount' => $postCount,
            'posts' => $formattedPosts,
        ]);
    }
    /*
    public function notificationUpdate()
    {
        // Fetch latest 4 unread comments and count unread comments
        $commentNotify = Task_Comments::with('commentUser')->latest()->take(4)->get();
        $commentCount = Task_Comments::where('is_read', false)->count();

        // Fetch latest 4 unread posts and count unread posts
        $postNotify = Task_Post::with('postuser')->latest()->take(4)->get();
        $postCount = Task_Post::where('is_read', false)->count();

        // Combine comments and posts into a single collection
        $notifications = collect();

        // Format and add comments to notifications
        foreach ($commentNotify as $comment) {
            $notifications->push([
                'type' => 'comment',
                'username' => optional($comment->commentUser)->name ?? 'Unknown User',
                'time' => $comment->created_at->diffForHumans(),
                'comments' => $comment->comments,

                'avatar' => optional($comment->commentUser)->profile_image
                    ? asset('storage/images/' . optional($comment->commentUser)->profile_image)
                    : asset('storage/images/Avatar.png'),
            ]);
        }

        // Format and add posts to notifications
        foreach ($postNotify as $post) {
            $notifications->push([
                'type' => 'post',
                'username' => optional($post->postuser)->name ?? 'Unknown User',
                'time' => $post->created_at->diffForHumans(),
                'content' => $post->post ?? 'No content available',
                'avatar' => optional($post->postuser)->profile_image
                    ? asset('storage/images/' . optional($post->postuser)->profile_image)
                    : asset('storage/images/Avatar.png'),
            ]);
        }

        // Group notifications by user
        $groupedNotifications = $notifications->groupBy('username');

        return response()->json([
            'commentCount' => $commentCount,
            'postCount' => $postCount,
            'notifications' => $groupedNotifications,
        ]);
    }*/
    public function taskNotification()
    {
        $taskNotify = Tasks::with('client')->where('is_read', false)->latest()->limit(5)->get();
        $taskCount  = Tasks::where('is_read', false)->count();

        if ($taskCount) {
            //$step1 = $taskCount->
        }
        return response()->json([
            'taskCount' => $taskCount,
            'taskNotify' => $taskNotify
        ]);
    }
    public function taskNotificationDelete($id)
    {
        $taskNotify = Tasks::find($id);
        $taskNotify->is_read = true;
        $taskNotify->save();
        return response()->json(['message' => 'Task read successfully']);
    }

    public function commentDelete($id)
    {
        $comment = Task_Comments::find($id);

        if ($comment) {
            $comment->is_read = true; // Use boolean true instead of string 'true'
            $comment->save(); // Use save() instead of update() for single model instance
            return response()->json(['message' => 'Comment marked as read successfully']);
        }

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

    public function showNotification()
    {
        $unreadComm = Task_Comments::with('commentUser')->get();
        return response()->json(['unreadComm' => $unreadComm,]);
    }
    //*********** Punch In  ***************//

    public function punchInBtn(Request $request)
    {
        try {
            // Ensure the user is authenticated
            if (!Auth::check()) {
                return response()->json([
                    'success' => false,
                    'message' => 'Unauthorized access!',
                ], 403);
            }
            $userId = Auth::id();

            $alreadyCheckedIn = CheckInTime::where('user_id', $userId)
                ->whereDate('checked_in_time', now()->toDateString())
                ->exists();

            if ($alreadyCheckedIn) {
                return response()->json([
                    'success' => false,
                    'message' => 'You have already punched in today!',
                ], 400);
            }

            // Create the punch-in record
            $attendance = CheckInTime::create([
                'user_id' => $userId,
                'checked_in_time' => now(),
            ]);

            return response()->json([
                'success' => true,
                'message' => 'Punch in successful!',
            ], 200);
        } catch (\Exception $e) {
            // Log the error for debugging
            Log::error('Punch-in error: ' . $e->getMessage());

            return response()->json([
                'success' => false,
                'message' => 'Punch in failed! Please try again.',
            ], 500);
        }
    }

    //*********** Punch Out  ***************//
    public function punchOut(Request $request)
    {
        try {
            // Ensure the user is authenticated
            if (!Auth::check()) {
                return response()->json([
                    'success' => false,
                    'message' => 'Unauthorized access!',
                ], 403);
            }
            $userId = Auth::id(); // Get the authenticated user's ID
            $alreadyCheckedOut = CheckOutTime::where('user_id', $userId)
                ->whereDate('checked_out_time', now()->toDateString())
                ->exists();

            if ($alreadyCheckedOut) {
                return response()->json([
                    'success' => false,
                    'message' => 'You have already punched in today!',
                ], 400);
            }
            // Create the punch-in record
            $attendance = CheckOutTime::create([
                'user_id' => $userId,
                'checked_out_time' => now(),
            ]);

            return response()->json([
                'success' => true,
                'message' => 'Punch Out successful!',
            ], 200);
        } catch (\Exception $e) {
            // Log the error for debugging
            Log::error('Punch-out error: ' . $e->getMessage());

            return response()->json([
                'success' => false,
                'message' => 'Punch Out failed! Please try again.',
            ], 500);
        }
    }
}
PK     ¨|[B“.…¯R  ¯R    RolePermissionController.phpnu „[µü¤        <?php

namespace App\Http\Controllers;

use App\Models\Role_has_Permission;
//use App\Http\Controllers\Auth;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth as FacadesAuth;
use Illuminate\Testing\Fluent\Concerns\Has;
use Spatie\Permission\Models\Permission;
use Spatie\Permission\Models\Role;
use Spatie\Permission\Traits\HasRoles;
use App\Http\Controllers\Auth;

class RolePermissionController extends Controller
{
    /*public $guard_name = 'web';
    function __construct()
    {
        $this->middleware('permission:product-list|product-create|product-edit|product-delete', ['only' => ['index', 'show']]);
        $this->middleware('permission:product-create', ['only' => ['create', 'store']]);
        $this->middleware('permission:product-edit', ['only' => ['edit', 'update']]);
        $this->middleware('permission:product-delete', ['only' => ['destroy']]);
    }*/
    public function index()
    {
        $roleResult = Role::all();
        return view('role.role', compact('roleResult'));
    }
    public function createview()
    {
        return view('role.permission');
    }
    public function store(Request $request)
    {
        $role = $request->validate([
            'rolename'    => 'required',
            'description' => 'required'
        ]);
        $roleCreate = new Role();
        $roleCreate->name         =   $request['rolename'];
        $roleCreate->description  =   $request['description'];
        $roleCreate->guard_name   =   $request['guard_name'];
        $roleCreate->save();
        return redirect()->back()->with('message', 'Your add new role successfuly');
    }
    public function edit(Request $request, $id)
    {
        $role = $request->validate([
            'rolename'    => 'required',
            'description' => 'required'
        ]);
        $role = Role::find($id);
        $role->name        =  $request['rolename'];
        $role->description =  $request['description'];
        $role->guard_name  =  $request['guard_name'];
        $role->update();
        return redirect()->back()->with('message', 'Your add new role successfuly');
    }
    public function delete()
    {
        //....code....
    }
    public function permission($id)
    {
        //return view('role.permission');
    }
    public function changePermission(Request $request, $id)
    {
        $role_data      = Role::find($id);
        $perm           = Role::findByName($role_data->name)->permissions;
        $all_permission = $perm->pluck('name')->toArray();

        if (!empty($all_permission)) {
            return view('role.change-permission', compact('all_permission', 'role_data'));
        } else {
            return view('role.change-permission', compact('all_permission', 'role_data'));
        }
    }

    public function changePermissionStore(Request $request)
    {
        $roleId = $request['role_id'];
        $role = Role::firstOrCreate(['id' => $request['role_id']]);
        //client module
        if ($request->has('client-view')) {
            $permission = Permission::firstOrCreate(['name' => 'client-view']);
            if (!$role->hasPermissionTo('client-view')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('client-view');
        }
        if ($request->has('client-add')) {
            $permission = Permission::firstOrCreate(['name' => 'client-add']);
            if (!$role->hasPermissionTo('client-add')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('client-add');
        }
        if ($request->has('client-edit')) {
            $permission = Permission::firstOrCreate(['name' => 'client-edit']);
            if (!$role->hasPermissionTo('client-edit')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('client-edit');
        }
        if ($request->has('client-delete')) {
            $permission = Permission::firstOrCreate(['name' => 'client-delete']);
            if (!$role->hasPermissionTo('client-delete')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('client-delete');
        }
        if ($request->has('client-contact-person')) {
            $permission = Permission::firstOrCreate(['name' => 'client-contact-person']);
            if (!$role->hasPermissionTo('client-contact-person')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('client-contact-person');
        }
        if ($request->has('assign-service')) {
            $permission = Permission::firstOrCreate(['name' => 'assign-service']);
            if (!$role->hasPermissionTo('assign-service')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('assign-service');
        }
        if ($request->has('portal-password')) {
            $permission = Permission::firstOrCreate(['name' => 'portal-password']);
            if (!$role->hasPermissionTo('portal-password')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('portal-password');
        }
        if ($request->has('new-company')) {
            $permission = Permission::firstOrCreate(['name' => 'new-company']);
            if (!$role->hasPermissionTo('new-company')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('new-company');
        }
        //Task module
        if ($request->has('task-view')) {
            $permission = Permission::firstOrCreate(['name' => 'task-view']);
            if (!$role->hasPermissionTo('task-view')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('task-view');
        }
        if ($request->has('task-add')) {
            $permission = Permission::firstOrCreate(['name' => 'task-add']);
            if (!$role->hasPermissionTo('task-add')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('task-add');
        }
        if ($request->has('task-edit')) {
            $permission = Permission::firstOrCreate(['name' => 'task-edit']);
            if (!$role->hasPermissionTo('task-edit')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('task-edit');
        }
        if ($request->has('task-delete')) {
            $permission = Permission::firstOrCreate(['name' => 'task-delete']);
            if (!$role->hasPermissionTo('task-delete')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('assign-staff');
        }
        if ($request->has('assign-staff')) {
            $permission = Permission::firstOrCreate(['name' => 'assign-staff']);
            if (!$role->hasPermissionTo('assign-staff')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('assign-staff');
        }
        if ($request->has('receive-document')) {
            $permission = Permission::firstOrCreate(['name' => 'receive-document']);
            if (!$role->hasPermissionTo('receive-document')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('receive-document');
        }
        //Service Module
        if ($request->has('service-view')) {
            $permission = Permission::firstOrCreate(['name' => 'service-view']);
            if (!$role->hasPermissionTo('service-view')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('service-view');
        }
        if ($request->has('service-add')) {
            $permission = Permission::firstOrCreate(['name' => 'service-add']);
            if (!$role->hasPermissionTo('service-add')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('service-add');
        }
        if ($request->has('service-edit')) {
            $permission = Permission::firstOrCreate(['name' => 'service-edit']);
            if (!$role->hasPermissionTo('service-edit')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('service-delete');
        }
        if ($request->has('service-delete')) {
            $permission = Permission::firstOrCreate(['name' => 'service-delete']);
            if (!$role->hasPermissionTo('service-delete')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('service-delete');
        }
        if ($request->has('service-delete')) {
            $permission = Permission::firstOrCreate(['name' => 'service-delete']);
            if (!$role->hasPermissionTo('service-delete')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('service-checklist');
        }
        if ($request->has('service-checklist')) {
            $permission = Permission::firstOrCreate(['name' => 'service-checklist']);
            if (!$role->hasPermissionTo('service-checklist')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('service-checklist');
        }
        //Dispatch Module
        if ($request->has('dispatch-view')) {
            $permission = Permission::firstOrCreate(['name' => 'dispatch-view']);
            if (!$role->hasPermissionTo('dispatch-view')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('dispatch-view');
        }
        if ($request->has('dispatch-add')) {
            $permission = Permission::firstOrCreate(['name' => 'dispatch-add']);
            if (!$role->hasPermissionTo('dispatch-add')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('dispatch-add');
        }
        if ($request->has('dispatch-edit')) {
            $permission = Permission::firstOrCreate(['name' => 'dispatch-edit']);
            if (!$role->hasPermissionTo('dispatch-edit')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('dispatch-edit');
        }
        if ($request->has('dispatch-delete')) {
            $permission = Permission::firstOrCreate(['name' => 'dispatch-delete']);
            if (!$role->hasPermissionTo('dispatch-delete')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('dispatch-delete');
        }
        if ($request->has('dispatch-dispatch')) {
            $permission = Permission::firstOrCreate(['name' => 'dispatch-dispatch']);
            if (!$role->hasPermissionTo('dispatch-dispatch')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('dispatch-dispatch');
        }
        //Reminder Module
        if ($request->has('reminder-view')) {
            $permission = Permission::firstOrCreate(['name' => 'reminder-view']);
            if (!$role->hasPermissionTo('reminder-view')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('reminder-view');
        }
        if ($request->has('reminder-add')) {
            $permission = Permission::firstOrCreate(['name' => 'reminder-add']);
            if (!$role->hasPermissionTo('reminder-add')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('reminder-add');
        }
        if ($request->has('reminder-edit')) {
            $permission = Permission::firstOrCreate(['name' => 'reminder-edit']);
            if (!$role->hasPermissionTo('reminder-edit')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('reminder-delete');
        }
        if ($request->has('reminder-delete')) {
            $permission = Permission::firstOrCreate(['name' => 'reminder-delete']);
            if (!$role->hasPermissionTo('reminder-delete')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('reminder-delete');
        }
        if ($request->has('reminder-complete')) {
            $permission = Permission::firstOrCreate(['name' => 'reminder-complete']);
            if (!$role->hasPermissionTo('reminder-complete')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('reminder-complete');
        }
        //Policies Module
        if ($request->has('policies-view')) {
            $permission = Permission::firstOrCreate(['name' => 'policies-view']);
            if (!$role->hasPermissionTo('policies-view')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('policies-view');
        }
        if ($request->has('policies-add')) {
            $permission = Permission::firstOrCreate(['name' => 'policies-add']);
            if (!$role->hasPermissionTo('policies-add')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('policies-add');
        }
        if ($request->has('policies-edit')) {
            $permission = Permission::firstOrCreate(['name' => 'policies-edit']);
            if (!$role->hasPermissionTo('policies-edit')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('policies-delete');
        }
        if ($request->has('policies-delete')) {
            $permission = Permission::firstOrCreate(['name' => 'policies-delete']);
            if (!$role->hasPermissionTo('policies-delete')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('policies-delete');
        }
        //Template Module
        if ($request->has('template-view')) {
            $permission = Permission::firstOrCreate(['name' => 'template-view']);
            if (!$role->hasPermissionTo('template-view')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('template-add');
        }
        if ($request->has('template-add')) {
            $permission = Permission::firstOrCreate(['name' => 'template-add']);
            if (!$role->hasPermissionTo('template-add')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('template-edit');
        }
        if ($request->has('template-edit')) {
            $permission = Permission::firstOrCreate(['name' => 'template-edit']);
            if (!$role->hasPermissionTo('template-edit')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('template-delete');
        }
        if ($request->has('template-delete')) {
            $permission = Permission::firstOrCreate(['name' => 'template-delete']);
            if (!$role->hasPermissionTo('template-delete')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('template-delete');
        }
        //People Module
        if ($request->has('user-view')) {
            $permission = Permission::firstOrCreate(['name' => 'user-view']);
            if (!$role->hasPermissionTo('user-view')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('user-view');
        }
        if ($request->has('user-edit')) {
            $permission = Permission::firstOrCreate(['name' => 'user-edit']);
            if (!$role->hasPermissionTo('user-edit')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('user-edit');
        }
        if ($request->has('user-add')) {
            $permission = Permission::firstOrCreate(['name' => 'user-add']);
            if (!$role->hasPermissionTo('user-add')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('user-add');
        }
        if ($request->has('user-delete')) {
            $permission = Permission::firstOrCreate(['name' => 'user-delete']);
            if (!$role->hasPermissionTo('user-delete')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('user-delete');
        }
        //Report Module
        if ($request->has('daily-report')) {
            $permission = Permission::firstOrCreate(['name' => 'daily-report']);
            if (!$role->hasPermissionTo('daily-report')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('daily-report');
        }
        if ($request->has('weekly-report')) {
            $permission = Permission::firstOrCreate(['name' => 'weekly-report']);
            if (!$role->hasPermissionTo('weekly-report')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('weekly-report');
        }
        if ($request->has('monthly-report')) {
            $permission = Permission::firstOrCreate(['name' => 'monthly-report']);
            if (!$role->hasPermissionTo('monthly-report')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('monthly-report');
        }
        if ($request->has('yearly-report')) {
            $permission = Permission::firstOrCreate(['name' => 'yearly-report']);
            if (!$role->hasPermissionTo('yearly-report')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('yearly-report');
        }
        if ($request->has('role-permission')) {
            $permission = Permission::firstOrCreate(['name' => 'role-permission']);
            if (!$role->hasPermissionTo('role-permission')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('role-permission');
        }
        if ($request->has('general-setting')) {
            $permission = Permission::firstOrCreate(['name' => 'general-setting']);
            if (!$role->hasPermissionTo('general-setting')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('general-setting');
        }
        if ($request->has('profile-setting')) {
            $permission = Permission::firstOrCreate(['name' => 'profile-setting']);
            if (!$role->hasPermissionTo('profile-setting')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('profile-setting');
        }
        if ($request->has('hrm-setting')) {
            $permission = Permission::firstOrCreate(['name' => 'hrm-setting']);
            if (!$role->hasPermissionTo('hrm-setting')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('hrm-setting');
        }
        if ($request->has('module-setting')) {
            $permission = Permission::firstOrCreate(['name' => 'module-setting']);
            if (!$role->hasPermissionTo('module-setting')) {
                $role->givePermissionTo($permission);
            }
        } else {
            $role->revokePermissionTo('module-setting');
        }

        return redirect()->back()->with('message', 'Permission are set successfully!');
    }
    public function addPermission(Request $request)
    {
        $role = $request->validate([
            'permission'    => 'required',
        ]);
        $role = new Permission();
        $role->name        =  $request['permission'];
        $role->guard_name  =  $request['guard_name'];
        $role->save();
        return redirect()->back()->with('message', 'Your add new role successfuly');
    }
    public function  createPermission(Request $request)
    {
        return view('role.create');
    }
    public function assignPermission(Request $request)
    {
        return view('role.role_has_permission');
    }
}
PK     ¨|[ðX†É•  •    ClientController.phpnu „[µü¤        <?php

namespace App\Http\Controllers;

use App\Models\DispatchJob;
use App\Models\Client;
use App\Models\Client_ContactPerson;
use App\Models\ClientsService;
use App\Models\CompanyType;
use App\Models\ContactPerson;
use App\Models\ContactPersonLimited;
use App\Models\ContactPersonPartner;
use App\Models\ContactPersonSole;
use App\Models\cp_limited;
use App\Models\cp_partners;
use App\Models\LimitedDirector;
use App\Models\LimitedShareholder;
use App\Models\Postcheck_Attachment;
use App\Models\Precheck_Attachment;
use App\Models\Prechecks;
use App\Models\Service;
use App\Models\Tasks;
use Illuminate\Auth\EloquentUserProvider;
use Illuminate\Auth\Events\Validated;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Support\Facades\Validator;

class ClientController extends Controller
{
    public function ClientView($id)
    {
        $client = Client::find($id);
        /************ For Limited Client ***********/
        $compType = $client->company_type;
        $contpersonLtd = ContactPersonLimited::where('client_id', '=', $id)->with('contactPersonltd')->get();
        $contpersonPtner = ContactPersonPartner::where('client_id', '=', $id)->with('contactPersonPtr')->get();
        $contactPerson = ContactPersonSole::where('client_id', '=', $id)->with('contactPersonSole')->get();

        $assignedserv = DB::table('client_services')
            ->join('services', 'client_services.services_id', '=', 'services.id')
            ->select('client_services.*', 'services.service_name')
            ->where('client_services.clients_id', $id)
            ->get();
        $recent =  Tasks::where('clients_id', $id)
            ->with('EachTask', 'userAssign', 'juniorAssign', 'client')->get();

        if ($compType == 'Sole Proprietor') {
            return view('client.views.soleproprietor', compact('client', 'contactPerson', 'recent', 'assignedserv'));
        } elseif ($compType == 'Partnership') {
            return view('client.views.partnership', compact('client', 'contpersonPtner', 'recent', 'assignedserv'));
        } elseif ($compType == 'Limited') {
            return view('client.views.limited', compact('client', 'contpersonLtd', 'recent', 'assignedserv'));
        } else {
            return redirect()->back();
        }
    }

    /****************** Checklist Report ******************/

    public function clientChecklistReport($id)
    {
        $client   = Client::find($id);
        $clientId = $client->id;
        $service = ClientsService::with('service')
            ->where('clients_id', $client->id)->get();

        return view('client.views.checklist.checklist_limited', compact('client', 'service', 'clientId'));
    }

    public function clientChecklistReportPartner($id)
    {
        $client   = Client::find($id);
        $clientId = $client->id;

        $service = ClientsService::with('service')
            ->where('clients_id', $client->id)->get();

        return view('client.views.checklist.checklist_partner', compact('client', 'service', 'clientId'));
    }

    public function clientChecklistReportSole($id)
    {
        $client   = Client::find($id);
        $clientId = $client->id;

        $service = ClientsService::with('service')
            ->where('clients_id', $client->id)->get();

        return view('client.views.checklist.checklist_sole', compact('client', 'service', 'clientId'));
    }
    public function clientChecklistData($id) {}
    public function checklistResultData(Request $request)
    {
        $serviceId     = $request->input('service_id');
        $selectedYear  = $request->input('period');
        $clientId      = $request->input('client');
        $selectedMonth = $request->input('month');

        /*$serviceId     = '56';
        $selectedYear  = '2024';
        $clientId      = '25';
        $selectedMonth = '01';*/

        $data = Tasks::where('clientservices_id', $serviceId)
            ->where('clients_id', $clientId) // Fixed: Changed '$client_id' to 'client_id'
            ->whereMonth('created_at', '=', $selectedMonth)
            ->whereYear('created_at', '=', $selectedYear)
            ->get();

        foreach ($data as $item) {
            /* $attach = Postcheck_Attachment::join('precheck_attachment', 'postcheck_attachment.task_id', '=', 'precheck_attachment.task_id')
                ->select('postcheck_attachment.*', 'precheck_attachment.precheck_attach')
                ->where('postcheck_attachment.task_id', $item->id)
                ->with('postcheckservice')
                ->get();*/
            $post = Postcheck_Attachment::where('task_id', $item->id)
                ->with('postcheckservice')
                ->get();

            $pre = Precheck_Attachment::where('task_id', $item->id)
                ->with('precheckservice')
                ->get();
            $attach = $post->merge($pre);
        }
        return response()->json($attach);
    }

    public function clients()
    {
        $result = Client::with('contactPeople')->get();
        return view('client.clients', compact('result'));
    }

    public function createClient()
    {
        return view('client.createClient');
    }
    //*************  Steps to Create New Client   ******************//
    public function step1(Request $request)
    {
        $compType = $request->input('companytype');
        if ($compType == '0') {
            $comp = 'Sole Proprietor';
            return view('client.soleproprietor', compact('comp'));
        } elseif ($compType == '1') {
            $comp = 'Partnership';
            return view('client.partnership')->with('comp', $comp);
        } elseif ($compType == '2') {
            $comp = 'Limited';
            return view('client.limited')->with('comp', $comp);
        } else {
            return redirect()->route('client.clienttype')->with('message', 'Please select company type!');
        }
    }
    public function step2a()
    {
        return view('client.soleproprietor');
    }

    /************ New Company Formation Sole Propeator ************/
    public function newCompany()
    {
        return view('client.newSole');
    }
    public function newCompanyStore(Request $request)
    {
        $newSole = $request->validate([
            'name'          =>  'required',
            'tradeas'       =>  'required',
            'phone_number'  =>  'required',
            'email'         =>  'required|email',

        ]);
        $newSole = Client::create([
            'name'          => $request->name,
            'tradeas'       => $request->tradeas,
            'phone_number'  => $request->phone_number,
            'email'         => $request->email,
            'isNew'         => $request->isNew,
            'company_type'  => $request->company_type
        ]);
        return redirect()->route('client.clients');
    }

    /********************* Assign Contact Person to New Company Formation ***************************/

    public function contactPersonForNewClient()
    {
        $contactPerson = ContactPerson::all();
        return view('client.contactPerson', compact('contactPerson'));
    }

    /********************* Assign Contact Person to New Company Formation ***************************/
    public function newSoleAssignContact(Request $request)
    {
        $clientName = $request->input('clientName');
        $contactper = Client::where('name', '=', $clientName)->firstOrFail();
        $id = $contactper->id;
        $contact = Client::find($id);
        if ($contact) {
            $contact->contactPerson_id = $request->input('contactPerson');
            $contact->update();
        }

        return redirect()->route('client.clients');
    }
    /****************** CLient Services Supspend ****************/
    public function suspendClientService($id)
    {
        $suspend = ClientsService::find($id);
        $suspend->status = "Suspend";
        $suspend->update();
        return redirect()->back()->with('message', 'Service Suspended successfully!');
    }
    /****************** CLient Services Activate ****************/
    public function activateClientService($id)
    {
        $suspend = ClientsService::find($id);
        $suspend->status = "Active";
        $suspend->update();
        return redirect()->back()->with('message', 'Service Activated Successfully!');
    }
    public function newCompanyService()
    {
        $service = Service::all();
        return view('client.servicelist', compact('service'));
    }
    public function newCompanyServiceStore(Request $request)
    {
        $addClient = Client::latest('created_at')->first();
        return redirect()->route('client.clients');
    }

    /********************* New Company Formation Partner Company ***************************/
    public function newCompanyPartner()
    {
        return view('client.newPartner');
    }
    public function newCompanyPartnerDataStore(Request $request)
    {
        $partnerFormation = Client::create([
            'name'         => $request['name'],
            'phone_number' => $request['phone_number'],
            'email'        => $request['email'],
            'isNew'        => $request['isNew'],
            'company_type' => $request['company_type']
        ]);

        return redirect()->route('client.clients');
    }
    /********************* New Company Formation Limited Company ***************************/
    public function newCompanyLimited()
    {
        return view('client.newLimited');
    }
    public function newCompanyLimitedData(Request $request)
    {
        $limitedFormation = Client::create([
            'name'         => $request['name'],
            'phone_number' => $request['phone_number'],
            'email'        => $request['email'],
            'isNew'        => $request['isNew'],
            'company_type' => $request['company_type']
        ]);

        return redirect()->route('client.clients');
    }

    /************* Create Client Sole Propeator Company *******************/
    public function step2(Request $request)
    {

        $validator = Validator::make($request->all(), [
            'name'           =>     '',
            'address1'       =>     '',
            'plot'           =>     '',
            'block'          =>     '',
            'house'          =>     '',
            'city'           =>     '',
            'phone_number'   =>     '',
            'email'          =>     '',
            'tin_number'     =>     '',

        ]);
        if ($validator->fails()) {
            return redirect()->back()->withErrors($validator)->withInput();
        } else {
            $tincertFile = null;
            if ($request->hasFile('tincert')) {
                $pdfFile = $request->file('tincert');
                $tincertFile = uniqid() . '.' . $pdfFile->getClientOriginalExtension();
                $pdfFile->storeAs('public/upload', $tincertFile);
            }
            $certRegName = null;
            if ($request->hasFile('certReg')) {
                $certReg = $request->file('certReg');
                $certRegName =  uniqid() . '.' . $certReg->getClientOriginalExtension();
                $certReg->storeAs('public/upload', $certRegName);
            }
            $certExtrName = null;
            if ($request->hasFile('certExtr')) {
                $certExtr = $request->file('certExtr');
                $certExtrName =  uniqid() . '.' . $certExtr->getClientOriginalExtension();
                $certExtr->storeAs('public/upload', $certExtrName);
            }
            $certVatName = null;
            if ($request->hasFile('certVat')) {
                $certVat = $request->file('certVat');
                $certVatName =  uniqid() . '.' . $certVat->getClientOriginalExtension();
                $certVat->storeAs('public/upload', $certVatName);
            }
            $proprietor = new Client();
            $proprietor->name              =    $request->name;
            $proprietor->tradeas           =    $request->tradeas;
            $proprietor->address1          =    $request->address1;
            $proprietor->block             =    $request->block;
            $proprietor->plot              =    $request->plot;
            $proprietor->house             =    $request->house;
            $proprietor->city              =    $request->city;
            $proprietor->phone_number      =    $request->phone_number;
            $proprietor->email             =    $request->email;
            $proprietor->tin_number        =    $request->tin_number;
            $proprietor->tinCert           =    $tincertFile;
            $proprietor->vrn               =    $request->vrn;
            $proprietor->certVat           =    $certVatName;
            // $proprietor->efin              =    $request->efin;
            // $proprietor->efin_password     =    $request->efin_password;
            $proprietor->tax_region        =    $request->taxRegion;
            // $proprietor->brelaORS          =    $request->brelaORS;
            $proprietor->CertofReg         =    $certRegName;
            $proprietor->CertExtr          =    $certExtrName;
            $proprietor->memart            =    $request->memart;
            $proprietor->CertRegDate       =    $request->CertRegDate;
            $proprietor->tax_file_location =    $request->tax_file_location;
            $proprietor->fiscal_yr         =    $request->fiscalYear;
            $proprietor->company_type      =    $request->compType;
            $proprietor->save();

            return redirect()->route('client.passwrd');
        }
    }

    /************* Create Client Partnership *******************/
    public function step3()
    {
        return view('client.partnership');
    }
    public function step3process(Request $request)
    {
        /*$fromForm = $request->validate([
            'name'           =>     '',
            'address1'       =>     '',
            'city'           =>     '',
            'phone_number'   =>     'numeric',
            'email'          =>     'email',
            'tin_number'     =>     '',
            'tinCert'        =>     'mimes:pdf',
            'certReg'        =>     'mimes:pdf',
            'certExtr'       =>     'mimes:pdf',
        ]);*/
        $tincertName = null;
        if ($request->hasFile('tinCert')) {
            $tincert = $request->file('tinCert');
            $tincertName = uniqid() . '.' . $tincert->getClientOriginalExtension();
            $tincert->storeAs('public/upload', $tincertName);
        }
        $certVatName = null;
        if ($request->hasFile('certVat')) {
            $certVat = $request->file('certVat');
            $certVatName = uniqid() . '.' . $certVat->getClientOriginalExtension();
            $certVat->storeAs('public/upload', $certVatName);
        }
        $certRegName = null;
        if ($request->hasFile('certReg')) {
            $certReg = $request->file('certReg');
            $certRegName =  uniqid() . '.' . $certReg->getClientOriginalExtension();
            $certReg->storeAs('public/upload', $certRegName);
        }
        $certExtrName = null;
        if ($request->hasFile('certExtr')) {
            $certExtr = $request->file('certExtr');
            $certExtrName =  uniqid() . '.' . $certExtr->getClientOriginalExtension();
            $certExtr->storeAs('public/upload', $certExtrName);
        }
        $partnershipDeedName = null;
        if ($request->hasFile('partnershipDeed')) {
            $partnershipDeed = $request->file('partnershipDeed');
            $partnershipDeedName =  uniqid() . '.' . $partnershipDeed->getClientOriginalExtension();
            $partnershipDeed->storeAs('public/upload', $partnershipDeedName);
        }
        $partner = new Client();
        $partner->name              =    $request->name;
        $partner->tradeas           =    $request->tradeas;
        $partner->address1          =    $request->address1;
        $partner->block             =    $request->block;
        $partner->plot              =    $request->plot;
        $partner->house             =    $request->house;
        $partner->city              =    $request->city;
        $partner->phone_number      =    $request->phone_number;
        $partner->email             =    $request->email;
        $partner->tin_number        =    $request->tin_number;
        $partner->tinCert           =    $tincertName;
        $partner->vrn               =    $request->vrn;
        $partner->certVat           =    $certVatName;
        //$partner->efin              =    $request->efin;
        //$partner->efin_password     =    $request->efin_password;
        $partner->tax_region        =    $request->taxRegion;
        // $partner->brelaORS          =    $request->brelaORS;
        $partner->CertofReg         =    $certRegName;
        $partner->CertRegDate       =    $request->CertRegDate;
        $partner->certExtr          =    $certExtrName;
        $partner->tax_file_location =    $request->tax_file_location;
        $partner->fiscal_yr         =    $request->fiscalYear;
        $partner->company_type       =    $request->compType;
        $partner->partnershipDeed    =    $partnershipDeedName;
        $partner->save();
        return redirect('/passwrd');
    }

    /************* Create Client Limited Company *******************/
    public function step4()
    {
        return view('client.limited');
    }
    public function step4process(Request $request)
    {
        /*$fromForm = $request->validate([
            'name'              =>     '',
            'address1'          =>     '',
            'city'              =>     '',
            'phone_number'      =>     '',
            'email'             =>     'email',
            'tin_number'        =>     '',
            'tinCert'           =>     'mimes:pdf',
            'certIncorporation' =>     'mimes:pdf',
            'memart'            =>     'mimes:pdf',
            'fiscalYear'        =>     '',
        ]);*/
        $tincertName = null;
        if ($request->hasFile('tinCert')) {
            $tincert = $request->file('tinCert');
            $tincertName = uniqid() . '.' . $tincert->getClientOriginalExtension();
            $tincert->storeAs('public/upload', $tincertName);
        }
        $certVatName = null;
        if ($request->hasFile('certVat')) {
            $certVat = $request->file('certVat');
            $certVatName =  uniqid() . '.' . $certVat->getClientOriginalExtension();
            $certVat->storeAs('public/upload', $certVatName);
        }
        $memartName = null;
        if ($request->hasFile('memart')) {
            $memart = $request->file('memart');
            $memartName =  uniqid() . '.' . $memart->getClientOriginalExtension();
            $memart->storeAs('public/upload', $memartName);
        }
        $certIncName = null;
        if ($request->hasFile('certIncorporation')) {
            $certInc = $request->file('certIncorporation');
            $certIncName =  uniqid() . '.' . $certInc->getClientOriginalExtension();
            $certInc->storeAs('public/upload', $certIncName);
        }

        $limited = new Client();
        $limited->name              =    $request->name;
        $limited->tradeas           =    $request->tradeas;
        $limited->address1          =    $request->address1;
        $limited->block             =    $request->block;
        $limited->plot              =    $request->plot;
        $limited->house             =    $request->house;
        $limited->city              =    $request->city;
        $limited->phone_number      =    $request->phone_number;
        $limited->email             =    $request->email;
        $limited->tin_number        =    $request->tin_number;
        $limited->tinCert           =    $tincertName;
        $limited->vrn               =    $request->vrn;
        $limited->certVat           =    $certVatName;
        //$limited->efin              =    $request->efin;
        //$limited->efin_password     =    $request->efin_password;
        $limited->tax_region        =    $request->taxRegion;
        //$limited->brelaORS          =    $request->brelaORS;
        $limited->CertRegDate       =    $request->CertRegDate;
        $limited->CertIncorp        =    $certIncName;
        $limited->memart            =    $memartName;
        $limited->fiscal_yr         =    $request->fiscalYear;
        $limited->company_type      =    $request->compType;
        $limited->paidup_share      =   $request->paidup_share;
        $limited->authorised_share  =   $request->authorised_share;

        $limited->save();
        return redirect('/passwrd')->with('clientname', 'name');
    }
    //************  Step to Edit Exiting Client  **************************//
    public function edit($id)
    {
        $client                 =  Client::find($id);
        $contactPer             =  ContactPerson::all();
        $assignContactPersonSP  =  ContactPersonSole::where('client_id', $id)->with('contactPersonSole')->get();
        $assignContactPerson    =  ContactPersonPartner::where('client_id', $id)->with('contactPersonPtr')->get();
        //$ContactPersonPartner   = cp_partners::where('client_id', $id)->with('cpPartner')->get();
        $assignContactPersonltd =  Client_ContactPerson::where('client_id', $id)->with('contactPerson')->get();
        //$shareholder            =  ContactPersonLimited::where('client_id', $id)->with('contactPersonltd')->get();
        $contactPersonltd       =  cp_limited::where('client_id', $id)->with('cpLimited')->get();
        $contactPersonPartner   =  cp_partners::where('client_id', $id)->with('contactPersonPartner')->get();
        $shareholder            = LimitedShareholder::where('client_id', $id)->with('contactPersonltd')->get();
        $director               = LimitedDirector::where('client_id', $id)->with('contactPersonltd')->get();

        $compType = $client->company_type;
        if ($compType == 'Sole Proprietor') {
            return view('client.soleproprietorupdate', compact('client', 'contactPer', 'assignContactPersonSP'));
        } elseif ($compType == 'Partnership') {
            return view('client.partnerupdate', compact('client', 'assignContactPerson', 'contactPer', 'assignContactPersonltd', 'contactPersonPartner'));
        } elseif ($compType == 'Limited') {
            return view('client.limitedupdate', compact('client', 'assignContactPersonltd', 'contactPer', 'shareholder', 'contactPersonltd', 'director'));
        } else {
            return redirect()->back();
        }
    }

    //*******  Update Solepropeator Company ***********//
    public function updateSole(Request $request, $id)
    {
        $sole = $request->validate([
            'clientname'     =>     'required',
            'address1'       =>     'required',
            'city'           =>     'required',
            'phone_number'   =>     'required',
            'email'          =>     'required|email',
            'tin_number'     =>     'required',

        ]);
        $proprietor = Client::find($id);

        if ($request->hasFile('tincert')) {
            $pdfFile = $request->file('tincert');
            $tincertName = uniqid() . '.' . $pdfFile->getClientOriginalExtension();
            $pdfFile->storeAs('public/upload', $tincertName);
            $proprietor->tinCert           =    $tincertName;
        }

        if ($request->hasFile('certReg')) {
            $certReg = $request->file('certReg');
            $certRegName =  uniqid() . '.' . $certReg->getClientOriginalExtension();
            $certReg->storeAs('public/upload', $certRegName);
            $proprietor->CertofReg         =    $certRegName;
        }

        if ($request->hasFile('certExtr')) {
            $certExtr = $request->file('certExtr');
            $certExtrName =  uniqid() . '.' . $certExtr->getClientOriginalExtension();
            $certExtr->storeAs('public/upload', $certExtrName);
            $proprietor->CertExtr          =    $certExtrName;
        }

        if ($request->hasFile('certVat')) {
            $certVat = $request->file('certVat');
            $certVatName =  uniqid() . '.' . $certVat->getClientOriginalExtension();
            $certVat->storeAs('public/upload', $certVatName);
            $proprietor->certVat           =    $certVatName;
        }
        if (!empty($request->fiscal_yr)) {
            $proprietor->fiscal_yr =  $request->input('fiscal_yr');
        }
        if (!empty($request->taxRegion)) {
            $proprietor->tax_region =  $request->input('taxRegion');
        }

        $proprietor->name              =    $request->clientname;
        $proprietor->tradeas           =    $request->tradeas;
        $proprietor->address1          =    $request->address1;
        $proprietor->block             =    $request->block;
        $proprietor->plot              =    $request->plot;
        $proprietor->house             =    $request->house;
        $proprietor->city              =    $request->city;
        $proprietor->phone_number      =    $request->phone_number;
        $proprietor->email             =    $request->email;
        $proprietor->tin_number        =    $request->tin_number;
        $proprietor->vrn               =    $request->vrn;
        $proprietor->efin              =    $request->efin;
        $proprietor->efin_password     =    $request->efin_password;
        $proprietor->brelaORS          =    $request->brelaORS;
        $proprietor->memart            =    $request->memart;
        $proprietor->CertRegDate       =    $request->CertRegDate;
        $proprietor->tax_file_location =    $request->tax_file_location;
        $proprietor->contactPerson_id  =    $request->contactPerson;

        $proprietor->update();
        return redirect()->back()->with('message', 'Changes saved successfully!');
    }

    //*******  Update Partnership  Company  ***********//
    public function updatePartner(Request $request, $id)
    {
        $fromForm = $request->validate([
            'name'           =>     'required',
            'address1'       =>     'required',
            'city'           =>     'required',
            'phone_number'   =>     'required',
            'email'          =>     'required|email',
            'tin_number'     =>     'required',
        ]);

        $partner = Client::find($id);

        if ($request->hasFile('tincert')) {
            $tincert = $request->file('tincert');
            $tincertName = uniqid() . '.' . $tincert->getClientOriginalExtension();
            $tincert->storeAs('public/upload', $tincertName);
            $partner->tincert           =    $tincertName;
        }

        if ($request->hasFile('certVat')) {
            $certVat = $request->file('certVat');
            $certVatName = uniqid() . '.' . $certVat->getClientOriginalExtension();
            $certVat->storeAs('public/upload', $certVatName);
            $partner->certVat          =    $certVatName;
        }

        if ($request->hasFile('certReg')) {
            $certReg = $request->file('certReg');
            $certRegName =  uniqid() . '.' . $certReg->getClientOriginalExtension();
            $certReg->storeAs('public/upload', $certRegName);
            $partner->CertofReg         =    $certRegName;
        }

        if ($request->hasFile('certExtr')) {
            $certExtr = $request->file('certExtr');
            $certExtrName =  uniqid() . '.' . $certExtr->getClientOriginalExtension();
            $certExtr->storeAs('public/upload', $certExtrName);
            $partner->CertExtr          =    $certExtrName;
        }

        if ($request->hasFile('partnershipDeed')) {
            $partnershipDeed = $request->file('partnershipDeed');
            $partnershipDeedName =  uniqid() . '.' . $partnershipDeed->getClientOriginalExtension();
            $partnershipDeed->storeAs('public/upload', $partnershipDeedName);
            $partner->partnershipDeed    =    $partnershipDeedName;
        }
        if (!empty($request->fiscal_yr)) {
            $partner->fiscal_yr =  $request->input('fiscal_yr');
        }
        if (!empty($request->taxRegion)) {
            $partner->tax_region =  $request->input('taxRegion');
        }

        $partner->name              =    $request->name;
        $partner->tradeas           =    $request->tradeas;
        $partner->address1          =    $request->address1;
        $partner->block             =    $request->block;
        $partner->plot              =    $request->plot;
        $partner->house             =    $request->house;
        $partner->city              =    $request->city;
        $partner->phone_number      =    $request->phone_number;
        $partner->email             =    $request->email;
        $partner->tin_number        =    $request->tin_number;
        $partner->vrn               =    $request->vrn;
        $partner->efin              =    $request->efin;
        $partner->efin_password     =    $request->efin_password;
        $partner->brelaORS          =    $request->brelaORS;
        $partner->memart            =    $request->memart;
        $partner->CertRegDate       =    $request->CertRegDate;
        $partner->tax_file_location =    $request->tax_file_location;
        $partner->contactPerson_id    =    $request->contactPerson;

        $partner->update();
        return redirect()->back()->with('message', 'Changes saved successfully!');
    }
    //*******  Update Client which is Limited  Company  ***********//
    public function updateLimited(Request $request, $id)
    {
        $limited = $request->validate([
            'name'           =>     'required',
            'address1'       =>     'required',
            'city'           =>     'required',
            'phone_number'   =>     'required',
            'email'          =>     'required|email',
            'tin_number'     =>     'required',
        ]);

        $limited = Client::find($id);

        if ($request->hasFile('tincert')) {
            $tincert     = $request->file('tincert');
            $tincertName = uniqid() . '.' . $tincert->getClientOriginalExtension();
            $tincert->storeAs('public/upload', $tincertName);
            $limited->tinCert           =    $tincertName;
        }
        if ($request->hasFile('certVat')) {
            $certVat     = $request->file('certVat');
            $certVatName = uniqid() . '.' . $certVat->getClientOriginalExtension();
            $certVat->storeAs('public/upload', $certVatName);
            $limited->certVat           =    $certVatName;
        }
        if ($request->hasFile('certIncorpo')) {
            $certIncorpo     = $request->file('certIncorpo');
            $certIncorpoName =  uniqid() . '.' . $certIncorpo->getClientOriginalExtension();
            $certIncorpo->storeAs('public/upload', $certIncorpoName);
            $limited->CertIncorp         =    $certIncorpoName;
        }
        if ($request->hasFile('memart')) {
            $memart     = $request->file('memart');
            $memartName =  uniqid() . '.' . $memart->getClientOriginalExtension();
            $memart->storeAs('public/upload', $memartName);
            $limited->memart          =    $memartName;
        }
        if (!empty($request->fiscal_yr)) {
            $limited->fiscal_yr =  $request->input('fiscal_yr');
        }
        if (!empty($request->taxRegion)) {
            $limited->tax_region =  $request->input('taxRegion');
        }


        $limited->name              =    $request->name;
        $limited->tradeas           =    $request->tradeas;
        $limited->address1          =    $request->address1;
        $limited->block             =    $request->block;
        $limited->plot              =    $request->plot;
        $limited->house             =    $request->house;
        $limited->city              =    $request->city;
        $limited->phone_number      =    $request->phone_number;
        $limited->email             =    $request->email;
        $limited->tin_number        =    $request->tin_number;
        $limited->vrn               =    $request->vrn;
        $limited->efin              =    $request->efin;
        $limited->efin_password     =    $request->efin_password;
        $limited->brelaORS          =    $request->brelaORS;
        $limited->CertRegDate       =    $request->CertRegDate;
        $limited->tax_file_location =    $request->tax_file_location;
        $limited->paidup_share      =    $request->paidup_share;
        $limited->paidup_total      =    $request->input('paidup_total');
        $limited->paidup_value      =    $request->input('paidup_value');
        $limited->authorised_share  =    $request->authorised_share;
        $limited->authorised_value  =    $request->authorised_value;
        $limited->authorised_total  =    $request->input('authorised_total');

        $limited->update();
        return redirect()->back()->with('message', 'Changes saved successfully!');
    }
    /*********** Assign Service to Client *****************/
    public function clientService($id)
    {
        $clients   = Client::find($id);
        $services  = Service::all();
        $servId    = Service::pluck('id');
        $clientServId    = ClientsService::pluck('services_id');
        $contpersonLtd   = ContactPersonLimited::where('client_id', '=', $id)->with('contactPersonltd')->get();
        $contpersonPtner = ContactPersonPartner::where('client_id', '=', $id)->with('contactPersonPtr')->get();
        $contactPerson   = ContactPersonSole::where('client_id', '=', $id)->with('contactPersonSole')->get();

        $result = DB::table('client_services')
            ->join('services', 'client_services.services_id', '=', 'services.id')
            ->select('client_services.*', 'services.service_name')
            ->where('client_services.clients_id', $id)
            ->get();

        $compType = $clients->company_type;
        if ($compType == 'Sole Proprietor') {
            return view('client.assignedService.assignservice.sole-proprietor', compact('clients', 'services', 'result', 'servId', 'clientServId', 'contactPerson'));
        } elseif ($compType == 'Partnership') {
            return view('client.assignedService.assignservice.partnership', compact('clients', 'services', 'result', 'servId', 'clientServId', 'contpersonPtner'));
        } elseif ($compType == 'Limited') {
            return view('client.assignedService.assignservice.limited', compact('clients', 'services', 'result', 'servId', 'clientServId', 'contpersonLtd'));
        } else {
            return redirect()->back();
        }

        return view('client.clientservice', compact('clients', 'services', 'result', 'servId', 'clientServId'));
    }
    /*public function assignService(Request $request)
    {
        $servSelected = $request->input('client_service');
        $client = $request->input('client');

        $servExist = DB::table('client_services')
            ->select('services_id')
            ->where('clients_id', '=', $client)
            ->get()
            ->pluck('services_id')
            ->toArray();

        $missingServices = array_diff($servSelected, $servExist);

        if (empty($missingServices)) {
            return redirect()->back()->with('error', 'All selected services already exist!');
        } else {
            foreach ($missingServices as $serv) {
                ClientsService::create([
                    'clients_id' => $client,
                    'services_id' => $serv
                ]);
            }
            return redirect()->back()->with('message', 'Successfully assigned new services!');
        }
    }*/
    public function assignService(Request $request)
    {
        $servSelected = $request->input('client_service');
        $client = $request->input('client');

        // ID of the default "ad-hoc" service
        $adHocServiceId = 3;  // Replace with the actual ID of the "ad-hoc service"

        // Ensure the "ad-hoc service" is always part of the assigned services
        if (!in_array($adHocServiceId, $servSelected)) {
            $servSelected[] = $adHocServiceId;
        }

        $servExist = DB::table('client_services')
            ->select('services_id')
            ->where('clients_id', '=', $client)
            ->get()
            ->pluck('services_id')
            ->toArray();

        $missingServices = array_diff($servSelected, $servExist);

        if (empty($missingServices)) {
            return redirect()->back()->with('error', 'All selected services already exist!');
        } else {
            foreach ($missingServices as $serv) {
                ClientsService::create([
                    'clients_id' => $client,
                    'services_id' => $serv
                ]);
            }
            return redirect()->back()->with('message', 'Successfully assigned new services!');
        }
    }

    public function assignServiceModal($id)
    {
        $clientServ = ClientsService::findOrFail($id);
        return response()->json($clientServ);
    }
    /************** End of Assign Service to Client ******************/
    public function getsole($id)
    {
        $clients = Client::with('clients')->find($id);
    }
    /************** Suspend the client*****************/
    public function suspendClient($id)
    {
        $susp = Client::find($id);
        $susp->status = "Inactive";
        $susp->update();
        return redirect()->back()->with('success', 'The client has been successfully Suspended!');
    }

    /************** Suspend the client*****************/
    public function reactivateClient($id)
    {
        $susp = Client::find($id);
        $susp->status = "Active";
        $susp->update();
        return redirect()->back()->with('success', 'The client has been successfully Reactivate!');
    }
    /************** View the client file that attached *****************/

    /************** Activate Pending Client To Active *************/
    public function activateClient($id)
    {
        $activate = Client::find($id);
        $activate->isNew = "No";
        $activate->update();
        return redirect()->route('client.clients');
    }
}
PK     ¨|[ójR¸  ¸    EmployeeController.phpnu „[µü¤        <?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use App\Models\Employee;
use App\Models\Role;
use App\Models\User;
use Illuminate\Support\Facades\Auth;

class EmployeeController extends Controller
{
    public function employees()
    {
        /*$role = Role::find(Auth::user()->role_id);
        if ($role->hasPermissionTo()) {
        }*/
        //$employees = Employee::paginate(4);
        $employees  = User::with('employeeUser')->paginate(6);
        return view('employee.employee', compact('employees'));
    }
    public function addNewEmployee()
    {
        //$users  = User::all();
        return view('employee.createEmployee');
    }
    public function editEmployees($id)
    {
        $employee = Employee::find($id);
        return view('employee.editemployee', compact('employee'));
    }
    public function updateEmployees(Request $request, $id)
    {
        $employees = Employee::find($id);

        if ($request->hasFile('images')) {
            $image = $request->file('images');
            $imageName = time() . '.' . $image->getClientOriginalExtension();
            $image->storeAs('public/images', $imageName);
        }
        $employees->first_name        =    $request->first_name;
        $employees->middle_name       =    $request->middle_name;
        $employees->last_name         =    $request->last_name;
        $employees->status            =    $request->status;
        $employees->images            =    $imageName;
        $employees->position          =    $request->position;
        $employees->cv                =    $request->cv;
        $employees->application       =    $request->application;
        $employees->offer_letter      =    $request->offer_letter;
        $employees->nssf              =    $request->nssf;
        $employees->termination       =    $request->termination;
        $employees->phone             =    $request->phone;
        $employees->email             =    $request->email;
        $employees->joining_date      =    $request->joining_date;
        $employees->contract_period   =    $request->contract_period;
        $employees->tin               =    $request->tin;
        $employees->nida              =    $request->nida;
        $employees->username          =    $request->username;
        $employees->password          =    $request->password;

        $employees->update();
        return redirect()->route('employee.employee');
    }

    public function store(Request $request)
    {
        $validate = $request->validate([
            'first_name'       => 'required',
            'middle_name'      => 'required',
            'last_name'        => 'required',
            'joining_date'     => 'required',
            'termination'      => 'required',
            'phone'            => 'required',
            'email'            => 'required',
        ]);
        if ($request->hasFile('images')) {
            $image = $request->file('images');
            $imageName = time() . '.' . $image->getClientOriginalExtension();
            $image->storeAs('public/images', $imageName);
        }

        if ($request->hasFile('cv')) {
            $cv = $request->file('cv');
            $cvDoc = uniqid() . '.' . $cv->getClientOriginalExtension();
            $cv->storeAs('public/upload', $cvDoc);
        }
        if ($request->hasFile('contract')) {
            $contract = $request->file('contract');
            $contractDoc = uniqid() . '.' . $contract->getClientOriginalExtension();
            $contract->storeAs('public/upload', $contractDoc);
        }
        if ($request->hasFile('application')) {
            $application = $request->file('application');
            $applicationDoc = uniqid() . '.' . $application->getClientOriginalExtension();
            $application->storeAs('public/upload', $applicationDoc);
        }
        if ($request->hasFile('offerletter')) {
            $offer_letter = $request->file('offerletter');
            $offer_letterDoc = uniqid() . '.' . $offer_letter->getClientOriginalExtension();
            $offer_letter->storeAs('public/upload', $offer_letterDoc);
        }

        $employees  = new Employee();
        $employees->first_name        =    $request->first_name;
        $employees->middle_name       =    $request->middle_name;
        $employees->last_name         =    $request->last_name;
        $employees->status            =    $request->status;
        $employees->images            =    $imageName;
        $employees->position          =    $request->position;
        $employees->cv                =    $cvDoc;
        $employees->contract          =    $contractDoc;
        $employees->application       =    $applicationDoc;
        $employees->offer_letter      =    $offer_letterDoc;
        $employees->nssf              =    $request->nssf;
        $employees->termination       =    $request->termination;
        $employees->phone             =    $request->phone;
        $employees->email             =    $request->email;
        $employees->joining_date      =    $request->joining_date;
        $employees->contract_period   =    $request->contract_period;
        $employees->tin               =    $request->tin;
        $employees->nida              =    $request->nida;
        $employees->user_id           =    $request->user_id;
        $employees->role_id           =    $request->role_id;

        $employees->save();
        return redirect()->route('employee.employee')->with('message', 'New employee added successfully.');
    }

    public function profile($id)
    {

        $user = User::find($id);
        //$user  = User::with('employeeUser')
        return view('employee.profile', compact('user'));
    }
    public function deleteEmployee($id) {}
}
PK     ¨|[KÞÿW  ÿW    ContactPersonController.phpnu „[µü¤        <?php

namespace App\Http\Controllers;

use App\Models\Client;
use App\Models\Client_ContactPerson;
use App\Models\ContactPerson;
use App\Models\ContactPersonLimited;
use App\Models\ContactPersonPartner;
use App\Models\ContactPersonSole;
use App\Models\cp_limited;
use App\Models\cp_partners;
use App\Models\LimitedDirector;
use App\Models\LimitedShareholder;
use Dotenv\Validator as DotenvValidator;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Validator;

class ContactPersonController extends Controller
{

    public function ContactPersonList()
    {
        $contactPerson = ContactPerson::all();
        return view('client.contactperson.contactpersonlist', compact('contactPerson'));
    }

    public function addContactPerson()
    {
        $clientId = Client::latest('created_at')->first();
        return view('client.contactperson.createContactPerson', compact('clientId'));
    }

    /*public function store(Request $request)
    {
        $contact = $request->validate([
            'tin'           =>  'required',
            'tin_cert'      =>  'required',
            'nidacopy'      =>  'required'
        ]);
        if ($request->hasFile('passportcopy')) {
            $passportcopy = $request->file('passportcopy');
            $passportcopyName =  uniqid() . '.' . $passportcopy->getClientOriginalExtension();
            $passportcopy->storeAs('public/uploads', $passportcopyName);
        } else {
            $passportcopyName = null;
        }
        if ($request->hasFile('nidacopy')) {
            $nidacopy = $request->file('nidacopy');
            $nidacopyName =  uniqid() . '.' . $nidacopy->getClientOriginalExtension();
            $nidacopy->storeAs('public/uploads', $nidacopyName);
        }
        if ($request->hasFile('tin_cert')) {
            $tinCert = $request->file('tin_cert');
            $tinCertName =  uniqid() . '.' . $tinCert->getClientOriginalExtension();
            $tinCert->storeAs('public/uploads', $tinCertName);
        }

        $contactPerson = new ContactPerson();

        //$contactPerson->client_id     =    $request->clientId;
        $contactPerson->first_name      =    $request->first_name;
        $contactPerson->middle_name     =    $request->middle_name;
        $contactPerson->last_name       =    $request->last_name;
        //$contactPerson->position      =    $request->position;
        $contactPerson->phone           =    $request->phone;
        $contactPerson->email           =    $request->email;
        $contactPerson->tin             =    $request->tin;
        //$contactPerson->nationality   =    $request->nationality;
        //$contactPerson->director      =    $request->director;
        $contactPerson->radio           =    $request->radio;
        $contactPerson->passport        =    $request->passport;
        $contactPerson->passportcopy    =    $passportcopyName;
        $contactPerson->nida            =    $request->nida;
        $contactPerson->nidacopy        =    $nidacopyName;
        $contactPerson->tinCert         =    $tinCertName;

        $contactPerson->save();
        return redirect()->back()->with('message', 'Successfuly create new contact person!');
    }*/
    public function store(Request $request)
    {
        // Validate required fields
        $validatedData = $request->validate([
            'tin' => 'required',
            // 'tin_cert' => 'required|file', // Ensure 'tin_cert' is a valid file
            // 'nidacopy' => 'required|file', // Ensure 'nidacopy' is a valid file
            //'first_name' => 'required|string',
            // 'last_name' => 'required|string',
            //'phone' => 'required|string',
            //'email' => 'required|email',
        ]);

        // Function to handle file uploads
        $uploadFile = function ($file) {
            return $file ? $file->storeAs('public/upload', uniqid() . '.' . $file->getClientOriginalExtension()) : null;
        };

        // Upload files if they exist
        $passportCopyPath = $request->hasFile('passportcopy') ? $uploadFile($request->file('passportcopy')) : null;
        $nidaCopyPath = $uploadFile($request->file('nidacopy'));
        $tinCertPath = $uploadFile($request->file('tin_cert'));

        // Create a new ContactPerson instance
        $contactPerson = new ContactPerson();
        $contactPerson->first_name = $request->input('first_name');
        $contactPerson->middle_name = $request->input('middle_name', null); // Optional
        $contactPerson->last_name = $request->input('last_name');
        $contactPerson->phone = $request->input('phone');
        $contactPerson->email = $request->input('email');
        $contactPerson->tin = $validatedData['tin'];
        $contactPerson->radio = $request->input('radio', null); // Optional
        $contactPerson->passport = $request->input('passport', null); // Optional
        $contactPerson->passportcopy = $passportCopyPath;
        $contactPerson->nida = $request->input('nida', null); // Optional
        $contactPerson->nidacopy = $nidaCopyPath;
        $contactPerson->tinCert = $tinCertPath;

        // Save the ContactPerson record
        $contactPerson->save();

        // Redirect back with success message
        return redirect()->back()->with('message', 'Successfully created a new contact person!');
    }

    /******************* Add New Partner **********************/
    public function AssignContactPerson(Request $request)
    {
        // Validate request data
        $valide = $request->validate([
            'contactPerson' => 'required|string',
            'sharePercent' => 'required|numeric|min:0|max:100',
        ]);
        $existingShareholder = ContactPersonPartner::where('contactpeople_id', $request->input('contactPerson'))
            ->where('client_id', $request->input('client'))->first();

        if ($existingShareholder) {
            return redirect()->back()
                ->withErrors(['error' => 'The partner already exists.'])
                ->withInput();
        }

        // Check if adding the new percentage would exceed 100%
        $currentTotalPercent = ContactPersonPartner::where('client_id', $request->input('client'))->sum('share_percent');
        $newPercent = $request->input('sharePercent');

        if ($currentTotalPercent + $newPercent > 100) {
            return redirect()->back()
                ->withErrors(['error' => 'The total percentage cannot exceed 100%.'])
                ->withInput();
        }
        ContactPersonPartner::create([
            'contactpeople_id' => $request->input('contactPerson'),
            'share_percent'    => $newPercent,
            'client_id'        => $request->client,
        ]);

        return redirect()->back()->with('message', 'Partner added successfully!');
    }
    /********************** Edit Partner *******************/

    public function EditPartner(Request $request, $id)
    {
        // Validate request data
        $validated = $request->validate([
            'sharePercent' => 'required|numeric|min:0|max:100',
        ]);
        $partner = ContactPersonPartner::find($id);
        // Check if the partner exists
        if (!$partner) {
            return redirect()->back()
                ->withErrors(['error' => 'Partner not found.'])
                ->withInput();
        }
        // Check if updating the percentage would exceed 100%
        $currentTotalPercent = ContactPersonPartner::where('client_id', $partner->client_id)
            ->where('id', '!=', $id)
            ->sum('share_percent');
        $newPercent = $request->input('sharePercent');
        if ($currentTotalPercent + $newPercent > 100) {
            return redirect()->back()
                ->withErrors(['error' => 'The total percentage cannot exceed 100%.'])
                ->withInput();
        }
        // Update the partner data in the database
        $partner->update([
            'share_percent' => $newPercent,
        ]);

        return redirect()->back()->with('message', 'Partner updated successfully!');
    }

    /*****************  Assign Contact Person for Partner ************/
    public function ContactPersonPtr(Request $request)
    {
        $ptrPerson = cp_partners::where('contactperson_id', $request->input('contactPerson'))
            ->where('client_id', $request->input('client'))->first();
        if ($ptrPerson) {
            return redirect()->back()
                ->withErrors(['error' => 'The contact person already exists!'])
                ->withInput();
        }
        $contPerson = cp_partners::create([
            'client_id'         =>   $request->client,
            'contactperson_id'  =>   $request->contactPerson,
        ]);
        return redirect()->back()->with('message', 'Contact person added successfully!');
    }

    /******************Edit Contact Partner *****************/
    public function EditContactPartner(Request $request, $id)
    {
        $partnerPerson = Client_ContactPerson::find($id);
        $partnerPerson = $request->input('contactPerson');
        $partnerPerson->update();
        return redirect()->back()->with('message', 'Contact person updated Successfully');
    }
    /********************Delete Contact Person from Partner *******************/

    public function DeleteContactPartner(Request $request, $id)
    {
        $partnerPerson = cp_partners::find($id);
        if (!$partnerPerson) {
            abort(403, "Unauthorized Access");
        }
        $partnerPerson->delete();
        return redirect()->back()->with('message', 'Contact Person deleted successfully!');
    }
    /******************** Edit Sole Proprietor *************/
    public function EditContactPerson(Request $request, $id)
    {

        $contPerson = ContactPersonSole::find($id);
        if ($contPerson) {
            $contPerson->role = $request->input('role');
            $contPerson->update();
        }
        return redirect()->back()->with('message', 'Contact Person update successfully!');
    }
    /****************** Edit Shareholder ***************/
    public function EditContactshareholder(Request $request, $id)
    {

        $shareholder = ContactPersonLimited::find($id);

        $sumPaidUpShares = ContactPersonLimited::where('client_id', $request->input('client'))->sum('number_shares');
        $totalPaidShares = Client::where('id', $request->input('client'))->first();
        if ($sumPaidUpShares >= $totalPaidShares) {
            return redirect()->back()
                ->withErrors(['error' => 'Number shares should not exceed Paid-up!'])
                ->withInput();
        }

        if ($shareholder) {
            $shareholder->number_shares      =   $request->numberShare;
            $shareholder->share_percent      =   $request->shareholding;
            $shareholder->update();
        }
        return redirect()->back()->with('message', 'Contact Person update successfully!');
    }

    /******************* Delete Person limited **********/

    public function deletePersonLtd($id)
    {
        $person = cp_limited::find($id);
        if (empty($person)) {
            return redirect()->back()->with('error', 'User is not found!');
        }
        $person->delete();
        return redirect()->back()->with('message', 'Contact Person deleted successfully!');
    }

    public function editPersonLtd(Request $request, $id)
    {
        $person = cp_limited::find($id);
        $person->client_id         =   $request->client;
        $person->contactpeople_id  =   $request->contactPerson;
        $person->update();
        return redirect()->back()->with('message', 'Contact Person updated successfully!');
    }

    /******************* Add Share holder and Directors to Limited Company *****************/
    public function AssignContactPersonLimited(Request $request)
    {
        $existingHolder = cp_limited::where('contactperson_id', $request->input('contactPerson'))
            ->where('client_id', $request->input('client'))
            ->first();

        if ($existingHolder) {
            return redirect()->back()
                ->withErrors(['error' => 'The contact person already exists!'])
                ->withInput();
        }

        /*
        $sumPaidUpShares = ContactPersonLimited::sum('number_shares');
        $totalPaidShares = Client::where('id', $request->input('client'))->first();
        if ($sumPaidUpShares >= $totalPaidShares) {
            return redirect()->back()
                ->withErrors(['error' => 'Number shares should not exceed Paid-up!'])
                ->withInput();
        }*/

        $contactPerson = new cp_limited();
        $contactPerson->client_id         =   $request->client;
        $contactPerson->contactperson_id  =   $request->contactPerson;
        $contactPerson->save();
        return redirect()->back()->with('message', 'Contact person added successfully!');
    }

    public function addDirectorLimited(Request $request)
    {
        $existingDirector = LimitedDirector::where('contactpeople_id', $request->input('contactPerson'))
            ->where('client_id', $request->input('client'))->first();

        if ($existingDirector) {
            return redirect()->back()
                ->withErrors(['error' => 'Director already exists!'])
                ->withInput();
        }
        $contactPerson = new LimitedDirector();
        $contactPerson->client_id        =  $request->client;
        $contactPerson->contactpeople_id =  $request->contactPerson;
        $contactPerson->save();

        return redirect()->back()->with('message', 'Director created successfully!');
    }

    public function ShareholderLimited(Request $request)
    {
        // Check if the shareholder already exists
        $existingHolder = LimitedShareholder::where('contactpeople_id', $request->input('contactPerson'))
            ->where('client_id', $request->input('client'))->first();

        if ($existingHolder) {
            return redirect()->back()
                ->withErrors(['error' => 'The shareholder already exists!'])
                ->withInput();
        }
        // Calculate existing paid-up shares and check if the new sum exceeds paid-up shares limit
        $paidUpSharesExist = LimitedShareholder::where('client_id', $request->input('client'))
            ->sum('number_shares');

        $addedPaidupShare = $request->input('numberShare');
        $newSum = $paidUpSharesExist + $addedPaidupShare;

        $clientPaidupShares = Client::where('id', $request->input('client'))->value('paidup_share');
        //return response()->json($clientPaidupShares);
        if ($newSum > $clientPaidupShares) {
            return redirect()->back()
                ->withErrors(['error' => 'Number of shares should not exceed Paid-up shares limit!'])
                ->withInput();
        }
        // Create a new shareholder
        $contactPerson = new LimitedShareholder();
        $contactPerson->client_id = $request->client;
        $contactPerson->contactpeople_id = $request->contactPerson;
        //$contactPerson->position = 'shareholder';
        $contactPerson->number_shares = $request->numberShare;
        $contactPerson->share_percent = $request->shareholding;
        $contactPerson->save();

        return redirect()->back()->with('message', 'Shareholder was created successfully!');
    }
    public function RemoveDirectorLimited($id)
    {
        $director = LimitedDirector::find($id);
        if ($director == null) {
            return response()->json(['error' => "Record not found"], 404);
        }
        $director->delete();
        return redirect()->back()->with('message', 'Director was deleted successfully!');
    }
    public function RemoveShareholder($id)
    {
        $shareholder = LimitedShareholder::find($id);
        if ($shareholder == null) {
            return response()->json(['error' => "Record not found"], 404);
        }
        $shareholder->delete();
        return redirect()->back()->with('message', 'Shareholder was deleted successfully!');
    }

    /******************************** Add Contact Person for Sole Prop **********************************/
    public function setContactPersonSole(Request $request)
    {
        $existingContactPerson = ContactPersonSole::where('contactpeople_id', $request->input('contactPerson'))->first();

        if ($existingContactPerson) {
            return redirect()->back()
                ->withErrors(['error' => 'The contact person already exists!'])
                ->withInput();
        }
        $contPerson = ContactPersonSole::create([
            'client_id'         =>   $request->client,
            'contactpeople_id'  =>   $request->contactPerson,
            'role'              =>   $request->role,
        ]);
        return redirect()->back()->with('message', 'Contact person added successfully!');
    }
    /******************************** Delete Contact Person for Sole Prop **********************************/
    public function deleteContactPersonSole($id)
    {
        $solePerson = ContactPersonSole::find($id);
        if ($solePerson == null) {
            return response()->json(['error' => "Record not found"], 404);
        }
        $solePerson->delete();
        return redirect()->back()->with('message', 'Contact Person deleted successfully!');
    }

    /******************************** Delete Partner for Partnership **********************************/
    public function deleteContactPersonPtnr($id)
    {
        $partner = ContactPersonPartner::find($id);
        if ($partner == null) {
            return response()->json(['error' => "Record not found"], 404);
        }
        $partner->delete();
        return redirect()->back()->with('message', 'Contact person deleted successfully!');
    }

    /******************************** Delete Partner for Partnership **********************************/
    public function deleteContactltd($id)
    {
        $limited = ContactPersonLimited::find($id);
        if ($limited == null) {
            return redirect()->back()->with('error', 'Shareholder not found!');
        }
        $limited->delete();
        return redirect()->back()->with('message', 'Shareholder deleted successfully!');
    }

    /*public function limitedassigncontact()
    {
        $limitedContPer = ContactPersonLimited::all();
        return view('client.limitedupdate', compact('limitedContPer'));
    }*/
    public function DeleteAssignedContactPerson($id)
    {
        $deleteContactPerson = ContactPersonPartner::find($id);
        $deleteContactPerson->delete();
        return redirect()->back()->with('message', '');
    }
    /**************  View Contact Person *************/
    public function viewContactPerson($id)
    {
        $contactPerson = ContactPerson::find($id);

        //$companyltd    = ContactPersonLimited::with('Assigneduser')->where('contactpeople_id', $contactPerson->id)->pluck('client_id');
        //$companyPtner    = ContactPersonPartner::with('contactPersonPtr')->where('contactpeople_id', $contactPerson->id)->pluck('client_id');
        //$companysole    = ContactPersonSole::with('contactPersonSole')->where('contactpeople_id', $contactPerson->id)->pluck('client_id');
        //$companyCpltd    = cp_limited::with('cpLimited')->where('contactperson_id', $contactPerson->id)->pluck('client_id');
        //$companyCptner    = cp_partners::with('contactPersonPartner')->where('contactperson_id', $contactPerson->id)->pluck('client_id');

        $companysole = Client::whereIn('id', ContactPersonSole::where('contactpeople_id', $contactPerson->id)->pluck('client_id'))->pluck('name');
        $companyCpltd = Client::whereIn('id', cp_limited::where('contactperson_id', $contactPerson->id)->pluck('client_id'))->pluck('name');
        $companyCptner = Client::whereIn('id', cp_partners::where('contactperson_id', $contactPerson->id)->pluck('client_id'))->pluck('name');

        return view('client.contactperson.viewprofile', compact('contactPerson', 'companysole', 'companyCpltd', 'companyCptner'));
    }

    /****************** Edit Contant Person ***************/
    public function ContactDetailEdit($id)
    {
        $editPerson  =  ContactPerson::find($id);
        return view('client.contactperson.editprofile', compact('editPerson'));
    }
    /********************** Save Contact  ***************/

    public function ContactDetailEditData(Request $request, $id)
    {
        $data = ContactPerson::find($id);
        if ($request->hasFile('passportcopy')) {
            $passportcopy = $request->file('passportcopy');
            $passportcopyName =  uniqid() . '.' . $passportcopy->getClientOriginalExtension();
            $passportcopy->storeAs('public/uploads', $passportcopyName);
            $data->passportcopy    =    $passportcopyName;
        }
        if ($request->hasFile('nidacopy')) {
            $nidacopy = $request->file('nidacopy');
            $nidacopyName =  uniqid() . '.' . $nidacopy->getClientOriginalExtension();
            $nidacopy->storeAs('public/uploads', $nidacopyName);
            $data->nidacopy        =    $nidacopyName;
        }
        if ($request->hasFile('tin_cert')) {
            $tinCert = $request->file('tin_cert');
            $tinCertName =  uniqid() . '.' . $tinCert->getClientOriginalExtension();
            $tinCert->storeAs('public/uploads', $tinCertName);
            $data->tinCert         =    $tinCertName;
        }
        $data->first_name      =    $request->first_name;
        $data->middle_name     =    $request->middle_name;
        $data->last_name       =    $request->last_name;
        $data->phone           =    $request->phone;
        $data->email           =    $request->email;
        $data->tin             =    $request->tin;
        $data->radio           =    $request->radio;
        $data->passport        =    $request->passport;
        $data->nida            =    $request->nida;
        $data->update();
        return redirect()->back()->with('message', 'Changes are updated successfully!');
    }
    public function ContactDetailDelete($id)
    {
        $item = ContactPerson::find($id);
        if (!empty($item)) {
            $item->contactPersonlmtd()->delete();
            $item->cpLimitedperson()->delete();
            $item->delete();
            return redirect()->route('client.ContactPersonList');
        } else {
            return redirect()->route('client.ContactPersonList');
        }
    }
}
PK     ¨|[fs>¯  ¯     Auth/ResetPasswordController.phpnu „[µü¤        <?php

namespace App\Http\Controllers\Auth;

use App\Http\Controllers\Controller;
use App\Providers\RouteServiceProvider;
use Illuminate\Foundation\Auth\ResetsPasswords;
use Illuminate\Support\Facades\Request as FacadesRequest;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Password;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Str;

class ResetPasswordController extends Controller
{
    /*
    |--------------------------------------------------------------------------
    | Password Reset Controller
    |--------------------------------------------------------------------------
    |
    | This controller is responsible for handling password reset requests
    | and uses a simple trait to include this behavior. You're free to
    | explore this trait and override any methods you wish to tweak.
    |
    */

    use ResetsPasswords;

    /**
     * Where to redirect users after resetting their password.
     *
     * @var string
     */
    protected $redirectTo = RouteServiceProvider::HOME;

    public function sendResetLink(FacadesRequest $request)
    {
        $request->validate(['email' => 'required|email']);

        // Attempt to send the reset link to the user
        $status = Password::sendResetLink($request->only('email'));

        return $status === Password::RESET_LINK_SENT
            ? back()->with('status', __($status))
            : back()->withErrors(['email' => __($status)]);
    }
}
PK     ¨|[‚ðKº›  ›  !  Auth/ForgotPasswordController.phpnu „[µü¤        <?php

namespace App\Http\Controllers\Auth;

use App\Http\Controllers\Controller;
use Illuminate\Foundation\Auth\SendsPasswordResetEmails;

class ForgotPasswordController extends Controller
{
    /*
    |--------------------------------------------------------------------------
    | Password Reset Controller
    |--------------------------------------------------------------------------
    |
    | This controller is responsible for handling password reset emails and
    | includes a trait which assists in sending these notifications from
    | your application to your users. Feel free to explore this trait.
    |
    */

    use SendsPasswordResetEmails;
}
PK     ¨|[ä÷„[      "  Auth/ConfirmPasswordController.phpnu „[µü¤        <?php

namespace App\Http\Controllers\Auth;

use App\Http\Controllers\Controller;
use App\Providers\RouteServiceProvider;
use Illuminate\Foundation\Auth\ConfirmsPasswords;

class ConfirmPasswordController extends Controller
{
    /*
    |--------------------------------------------------------------------------
    | Confirm Password Controller
    |--------------------------------------------------------------------------
    |
    | This controller is responsible for handling password confirmations and
    | uses a simple trait to include the behavior. You're free to explore
    | this trait and override any functions that require customization.
    |
    */

    use ConfirmsPasswords;

    /**
     * Where to redirect users when the intended url fails.
     *
     * @var string
     */
    protected $redirectTo = RouteServiceProvider::HOME;

    /**
     * Create a new controller instance.
     *
     * @return void
     */
    public function __construct()
    {
        $this->middleware('auth');
    }
}
PK     ¨|[gkHoê  ê    Auth/LoginController.phpnu „[µü¤        <?php

namespace App\Http\Controllers\Auth;

use App\Http\Controllers\Controller;
use App\Providers\RouteServiceProvider;
use Illuminate\Foundation\Auth\AuthenticatesUsers;

class LoginController extends Controller
{
    /*
    |--------------------------------------------------------------------------
    | Login Controller
    |--------------------------------------------------------------------------
    |
    | This controller handles authenticating users for the application and
    | redirecting them to your home screen. The controller uses a trait
    | to conveniently provide its functionality to your applications.
    |
    */

    use AuthenticatesUsers;

    /**
     * Where to redirect users after login.
     *
     * @var string
     */
    protected $redirectTo = RouteServiceProvider::HOME;

    /**
     * Create a new controller instance.
     *
     * @return void
     */
    public function __construct()
    {
        $this->middleware('guest')->except('logout');
    }
}
PK     ¨|[î-¬“j  j    Auth/VerificationController.phpnu „[µü¤        <?php

namespace App\Http\Controllers\Auth;

use App\Http\Controllers\Controller;
use App\Providers\RouteServiceProvider;
use Illuminate\Foundation\Auth\VerifiesEmails;

class VerificationController extends Controller
{
    /*
    |--------------------------------------------------------------------------
    | Email Verification Controller
    |--------------------------------------------------------------------------
    |
    | This controller is responsible for handling email verification for any
    | user that recently registered with the application. Emails may also
    | be re-sent if the user didn't receive the original email message.
    |
    */

    use VerifiesEmails;

    /**
     * Where to redirect users after verification.
     *
     * @var string
     */
    protected $redirectTo = RouteServiceProvider::HOME;

    /**
     * Create a new controller instance.
     *
     * @return void
     */
    public function __construct()
    {
        $this->middleware('auth');
        $this->middleware('signed')->only('verify');
        $this->middleware('throttle:6,1')->only('verify', 'resend');
    }
}
PK     ¨|[6Sÿë      Auth/RegisterController.phpnu „[µü¤        <?php

namespace App\Http\Controllers\Auth;

use App\Http\Controllers\Controller;
use App\Providers\RouteServiceProvider;
use App\Models\User;
use Illuminate\Foundation\Auth\RegistersUsers;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Facades\Validator;

class RegisterController extends Controller
{
    /*
    |--------------------------------------------------------------------------
    | Register Controller
    |--------------------------------------------------------------------------
    |
    | This controller handles the registration of new users as well as their
    | validation and creation. By default this controller uses a trait to
    | provide this functionality without requiring any additional code.
    |
    */

    use RegistersUsers;

    /**
     * Where to redirect users after registration.
     *
     * @var string
     */
    protected $redirectTo = RouteServiceProvider::HOME;

    /**
     * Create a new controller instance.
     *
     * @return void
     */
    public function __construct()
    {
        $this->middleware('guest');
    }

    /**
     * Get a validator for an incoming registration request.
     *
     * @param  array  $data
     * @return \Illuminate\Contracts\Validation\Validator
     */
    protected function validator(array $data)
    {
        return Validator::make($data, [
            'name' => ['required', 'string', 'max:255'],
            'email' => ['required', 'string', 'email', 'max:255', 'unique:users'],
            'password' => ['required', 'string', 'min:8', 'confirmed'],
            'role_id'    =>  ['required']
        ]);
    }

    /**
     * Create a new user instance after a valid registration.
     *
     * @param  array  $data
     * @return \App\Models\User
     */
    protected function create(array $data)
    {

        $newUser = User::create([
            'name'      =>  $data['name'],
            'email'     =>  $data['email'],
            'password'  =>  Hash::make($data['password']),
            'role'      =>  $data['role_id']
        ]);
    }
}
PK     ¨|[k®±˜}  }    PDFController.phpnu „[µü¤        <?php

namespace App\Http\Controllers;

use App\Models\CustomDispatchJob;
use App\Models\DispatchJob;
use App\Models\DocumentDispatchJob;
use App\Models\GeneralSetting;
use App\Models\RecieveDoc;
use Barryvdh\DomPDF\Facade\Pdf;
use Barryvdh\DomPDF\PDF as DomPDFPDF;
use Illuminate\Contracts\Session\Session as SessionSession;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Storage;
use Symfony\Component\HttpFoundation\Session\Session;

class PDFController extends Controller
{
    public function generate()
    {
        $data = [
            'title' => 'Mars',
            'content' => 'Sample PDF content goes here.',
        ];

        $pdf = app('dompdf.wrapper')->loadView('pdf/sample', $data);
        //return $pdf->stream('document.pdf');
        return $pdf->download('document.pdf');
    }
    public function generatedispatch()
    {
    }
    public function DispatchPDF(Request $request)
    {
        $logo           = GeneralSetting::pluck('logo')->first();
        $uniqueName     = 'dispatchDocs_' . uniqid() . '.pdf';
        $lastDispatchJob = DocumentDispatchJob::latest('dispatch_no')->first(); // Get the latest DispatchJob record
        if ($lastDispatchJob) {
            $lastNumber = intval(substr($lastDispatchJob->dispatch_no, 1));
            $dispatchNumber = 'D' . str_pad($lastNumber + 1, 4, '0', STR_PAD_LEFT);
        } else {
            // If no DispatchJob exists yet, start with C0001
            $dispatchNumber = 'D0001';
        }

        $pdf = app('dompdf.wrapper')->loadView('pdf/dispatchDocs', [
            'logo'                =>   $logo,
            'dispatch_number'     =>   $dispatchNumber,
            'client_name'         =>   $request->input('selected_client'),
            'client_address'      =>   $request->input('client_address'),
            'dispatch_date'       =>   $request->input('date_of_disp'),
            'date_doc_receive'    =>   $request->input('date_doc_receive'),
            'disp_doc_desc'       =>   $request->input('disp_doc_desc'),
            'disp_doc_qty'        =>   $request->input('disp_doc_qty'),
            'disp_doc_chckout'    =>   $request->input('disp_doc_chckout'),
            'disp_doc_narration'  =>   $request->input('disp_doc_narration'),
            /*'cust_disp_desc'    =>   $request->input('cust_disp_desc'),
            'cust_disp_checkout'  =>   $request->input('cust_disp_checkout'),
            'cust_disp_narration' =>   $request->input('cust_disp_narration'),*/
            'disp_note'           =>   $request->input('disp_note')
        ]);

        $checkOutQty = $request->disp_doc_chckout;
        $taskId      = $request->dispatchTask;
        $serviceId   = $request->dispatchService;
        $receiveDocs = RecieveDoc::where('task_id', $taskId)
            ->where('service_id', $serviceId)
            ->get();

        foreach ($receiveDocs as $index => $receiveDoc) {
            $newQuantity = $receiveDoc->quantity - $checkOutQty[$index];
            $receiveDoc->quantity = $newQuantity;
            $receiveDoc->save();
        }

        Storage::put('public/dispatch/' . $uniqueName, $pdf->output());
        $document = new DocumentDispatchJob();
        $document->client_name         =  $request->input('selected_client');
        $document->dispatchCreator     =  $request->input('dispatchCreator');
        $document->dispatch_attachment =  $uniqueName;
        $document->dispatch_no         =  $dispatchNumber;
        $document->save();

        return $pdf->stream('dispatchDocs.pdf');
    }
    //Custom dispatch
    public function customDispatchPDF(Request $request)
    {
        $logo           = GeneralSetting::pluck('logo')->first();
        $uniqueName     = 'dispatchDocs_' . uniqid() . '.pdf';
        $lastDispatchJob = CustomDispatchJob::latest('dispatch_no')->first(); // Get the latest DispatchJob record
        if ($lastDispatchJob) {
            $lastNumber = intval(substr($lastDispatchJob->dispatch_no, 1));
            $dispatchNumber = 'C' . str_pad($lastNumber + 1, 4, '0', STR_PAD_LEFT);
        } else {
            // If no DispatchJob exists yet, start with C0001
            $dispatchNumber = 'C0001';
        }

        $pdf = app('dompdf.wrapper')->loadView('pdf/customDispatchPDF', [
            'logo'                =>   $logo,
            'dispatch_number'     =>   $dispatchNumber,
            'client_name'         =>   $request->input('selected_client'),
            'client_address'      =>   $request->input('client_address'),
            'dispatch_date'       =>   $request->input('date_of_disp'),
            /*'date_doc_receive'  =>   $request->input('date_doc_receive'),
            'disp_doc_desc'       =>   $request->input('disp_doc_desc'),
            'disp_doc_qty'        =>   $request->input('disp_doc_qty'),
            'disp_doc_chckout'    =>   $request->input('disp_doc_chckout'),
            'disp_doc_narration'  =>   $request->input('disp_doc_narration'),*/
            'cust_disp_desc'      =>   $request->input('cust_disp_desc'),
            'cust_disp_checkout'  =>   $request->input('cust_disp_checkout'),
            'cust_disp_narration' =>   $request->input('cust_disp_narration'),
            'disp_note'           =>   $request->input('disp_note')
        ]);

        $checkOutQty = $request->disp_doc_chckout;
        $taskId      = $request->dispatchTask;
        $serviceId   = $request->dispatchService;
        $receiveDocs = RecieveDoc::where('task_id', $taskId)
            ->where('service_id', $serviceId)
            ->get();

        foreach ($receiveDocs as $index => $receiveDoc) {
            $newQuantity = $receiveDoc->quantity - $checkOutQty[$index];
            $receiveDoc->quantity = $newQuantity;
            $receiveDoc->save();
        }

        Storage::put('public/customDispatch/' . $uniqueName, $pdf->output());
        $document = new CustomDispatchJob();
        $document->client_name         =  $request->input('selected_client');
        $document->dispatchCreator     =  $request->input('dispatchCreator');
        $document->dispatch_attachment =  $uniqueName;
        $document->dispatch_no         =  $request->$dispatchNumber;
        $document->save();

        return $pdf->stream('customDispatch.pdf');
        //return response()->json(['success' => true, 'pdf_url' => route('view_pdf', ['filename' => $uniqueName])]);
    }
    public function viewPdf()
    {
        // return view('pdf.dispatchDocs', compact(''));
    }
}
PK     ¨|[©dŒâ	  â	    UserController.phpnu „[µü¤        <?php

namespace App\Http\Controllers;

use App\Models\Role;
use App\Models\User;
use Illuminate\Http\Request;
use Spatie\Permission\Traits\HasRoles;
use Illuminate\Support\Facades\Hash;

class UserController extends Controller
{
    use HasRoles;

    public function index()
    {
        return view('user.adduser');
    }
    public function addview()
    {
        $user = User::with('roleuser')->get();
        return view('user.userlist', compact('user'));
    }
    public function store()
    {
        //... code...
    }
    public function editview($id)
    {
        $user = User::find($id);
        return view('user.edit', compact('user'));
    }
    public function delete($id)
    {
        $user = User::find($id);
        if ($user) {
            $user->delete();
            return redirect()->back()->with('message', 'User has been deleted successfully!');
        } else {
            return redirect()->back()->with('error', 'User not found!');
        }
    }
    public function suspend($id)
    {
        $user = User::find($id);
        if ($user) {
            $user->status = "Inactive";
            $user->update();
            return redirect()->back()->with('message', 'User has been suspended!');
        } else {
            return redirect()->back()->with('error', 'User not found!');
        }
    }
    public function active($id)
    {
        $bannedUser = User::find($id);
        if ($bannedUser) {
            $bannedUser->status = "Active";
            $bannedUser->update();
            return redirect()->back()->with('message', 'User has been activated successfully!');
        } else {
            return redirect()->back()->with('error', 'User not found!');
        }
    }
    public function permission($id)
    {
        $user = User::find($id);
        return view('role.permission', compact('user'));
    }
    public function changepermission(Request $request, $id)
    {
    }
    public function changePassIndex(Request $request, $id)
    {
        $target = User::find($id);
        if (!$target) {
            abort(404);
        } else {
            return view('user.change_password', compact('target'));
        }
    }
    public function changePassUpdate(Request $request, $id)
    {
        $targetuser = User::find($id);

        if ($targetuser) {
            $targetuser->password = Hash::make($request->input('password'));
            $targetuser->update();
        }
        return redirect()->back()->with('message', 'Password updated successfully!');
    }
}
PK     ¨|[¿“¦ýS  S    ErrorLog.phpnu „[µü¤        <?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class ErrorLog extends Controller
{
    public function error404()
    {
        return view('error.404');
    }
    public function error409()
    {
        return view('error.409');
    }
    public function error403()
    {
        return view('error.403');
    }
}
PK     ¨|[-îý÷Y  Y    ProfileSettingController.phpnu „[µü¤        <?php

namespace App\Http\Controllers;

use App\Models\Employee;
use App\Models\User;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;

class ProfileSettingController extends Controller
{
    public function saveProfileSettings()
    {
        $user = User::with('employeeUser')->find(Auth::id());
        return view('settings.profile.edit-profile', compact('user'));
    }
    public function profilesetting()
    {
        $user = Auth::user();
        // $role = Auth::user()->role_id;
        //  return response()->json($role);
        if (Auth::user()->role_id == 1) {
            return  view('settings.profile.admin-profile', compact('user'));
        } elseif (Auth::user()->role_id == 2) {
            return  view('settings.profile.cordinator-profile', compact('user'));
        } elseif (Auth::user()->role_id == 3) {
            return  view('settings.profile.senior-profile', compact('user'));
        } elseif (Auth::user()->role_id == 4) {
            return  view('settings.profile.junior-profile', compact('user'));
        } else {
            return false;
        }
    }
}
PK     ¨|[V5µ	  µ	    RemindersController.phpnu „[µü¤        <?php

namespace App\Http\Controllers;


use App\Models\Reminders;
use App\Http\Controllers\View;
use Carbon\Carbon;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;


class RemindersController extends Controller
{
    public function reminder()
    {
        $reminders = Reminders::latest()->get();
        $now = Carbon::now();
        $dateNow = $now->format('Y-m-d');
        $timeNow = $now->format('H:i:s');
        return view('reminder.reminder', compact('reminders', 'dateNow', 'timeNow'));
    }

    public function createReminder(Request $request)
    {
        return view('reminder.createreminder');
    }
    public function createReminderdata(Request $request)
    {
        $reminder = new Reminders();
        $reminder->name          =   $request->input('name');
        $reminder->description   =   $request->input('description');
        $reminder->date          =   $request->input('date');
        $reminder->time          =   $request->input('time');
        $reminder->frequency     =   $request->input('frequency');

        $reminder->save();
        return redirect()->back()->with('message', 'Reminder created successfully');
    }
    public function calendar()
    {
        return view('reminder.calendar');
    }

    public function updateview($id)
    {
        $reminder = Reminders::find($id);
        return view('reminder.reminder', compact('reminder'));
        /*if (empty($reminderId)) {
            return redirect()->back()->with('error', 'Reminder not found!');
        } else {
            return view('reminder.reminder', compact('reminder'));
        }*/
    }
    public function  editReminderData($id) {}
    public function  editReminderIndex($id)
    {
        $reminder = Reminders::find($id);
        return view('reminder.editreminder', compact('reminder'));
    }
    public function update(Request $request)
    {
        $reminderUpdate =  new Reminders();

        $reminderUpdate->name          =   $request->reminder_name;
        $reminderUpdate->description   =   $request->description;
        $reminderUpdate->date          =   $request->reminder_date;
        $reminderUpdate->time          =   $request->reminder_time;
        $reminderUpdate->frequency     =   $request->frequency;
    }
    public function reminderdelete($id)
    {
        $reminder = Reminders::find($id);
        $reminder->delete();
        return redirect()->back()->with('message', 'Reminder is successfuly deleted!');
    }
}
PK     ¨|[æù/¤8  ¤8    RegController.phpnu „[µü¤        <?php

namespace App\Http\Controllers;

use App\Models\User;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Hash;

class RegController extends Controller
{
    /*public function create(Request $request)
    {
        $username = $request->input('name');
        /*$request->validate([
            'name'     => 'required|string|max:255',
            'email'    => 'required|string|email|max:255|unique:users',
            'password' => 'required|min:6|confirmed',
        ]);
        $imageName = null;
        if ($request->hasFile('images')) {
            $image = $request->file('images');
            $imageName = time() . '.' . $image->getClientOriginalExtension();
            $image->storeAs('public/images', $imageName);
        }
        $cvDoc = null;
        if ($request->hasFile('cv')) {
            $cv = $request->file('cv');
            $cvDoc = uniqid() . '.' . $cv->getClientOriginalExtension();
            $cv->storeAs('public/upload', $cvDoc);
        }
        $contractDoc = null;
        if ($request->hasFile('contract')) {
            $contract = $request->file('contract');
            $contractDoc = uniqid() . '.' . $contract->getClientOriginalExtension();
            $contract->storeAs('public/upload', $contractDoc);
        }
        $applicationDoc = null;
        if ($request->hasFile('application')) {
            $application = $request->file('application');
            $applicationDoc = uniqid() . '.' . $application->getClientOriginalExtension();
            $application->storeAs('public/upload', $applicationDoc);
        }
        /* $offerletterDoc = null;
        if ($request->hasFile('offerletter')) {
            $offer_letter = $request->file('offerletter');
            $offerletterDoc = uniqid() . '.' . $offer_letter->getClientOriginalExtension();
            $offer_letter->storeAs('public/upload', $offerletterDoc);
        }

        if ($request->input('role_id') === '1') {

            User::create([
                'name'          =>   $request->input('name'),
                'email'         =>   $request->input('email'),
                'phone'             =>   $request->input('phone'),
                'password'      =>   Hash::make($request->input('password')),
                'role_id'       =>   $request->input('role_id'),
                'profile_image' =>   $imageName
            ]);
            return redirect()->back()->with('message', 'Admin created successfully!');
        } else {
            User::create([
                'name'              =>   $request->input('name'),
                'email'             =>   $request->input('email'),
                'password'          =>   Hash::make($request->input('password')),
                'role_id'           =>   $request->input('role_id'),
                'profile_image'     =>   $imageName,
                'first_name'        =>   $request->input('first_name'),
                'middle_name'       =>   $request->input('middle_name'),
                'last_name'         =>   $request->input('last_name'),
                'status'            =>   $request->input('status'),
                'position'          =>   $request->input('position'),
                'cv'                =>   $cvDoc,
                'contract'          =>   $contractDoc,
                'application'       =>   $applicationDoc,
                //'offer_letter'      =>   $offerletterDoc,
                'nssf'              =>   $request->input('nssf'),
                'enddate'           =>   $request->input('enddate'),
                'phone'             =>   $request->input('phone'),
                'joining_date'      =>   $request->input('joining_date'),
                'start_date'        =>   $request->input('start_date'),
                //'termination'       =>   $request->input('termination'),
                'termination_date'  =>   $request->input('termination_date'),
                'termination_letter' =>   $request->input('termination_letter'),
                'contract_period'   =>   $request->input('contract_period'),
                'tin'               =>   $request->input('tin'),
                'nida'              =>   $request->input('nida')
            ]);

            return redirect()->back()->with('message', 'User created successfully!');
        }
    }*/
    public function createUser(Request $request)
    {
        $request->validate([
            'name'     => 'required|string|max:255',
            'email'    => 'required|string|email|max:255|unique:users',
            //'password' => 'required|min:6|confirmed',
        ]);

        $imageName = $this->handleFileUpload($request->file('images'), 'public/images');
        $cvDoc = $this->handleFileUpload($request->file('cv'), 'public/upload');
        $contractDoc = $this->handleFileUpload($request->file('contract'), 'public/upload');
        $applicationDoc = $this->handleFileUpload($request->file('application'), 'public/upload');

        $data = [
            'name'          => $request->input('name'),
            'phone'         => $request->input('phone'),
            'email'         => $request->input('email'),
            'password'      => Hash::make($request->input('password')),
            'role_id'       => $request->input('role_id'),
            'profile_image' => $imageName,
        ];

        if ($request->input('role_id') != 1) {
            $additionalData = [
                'first_name'        => $request->input('first_name'),
                'middle_name'       => $request->input('middle_name'),
                'last_name'         => $request->input('last_name'),
                'status'            => $request->input('status'),
                'position'          => $request->input('position'),
                'cv'                => $cvDoc,
                'contract'          => $contractDoc,
                'application'       => $applicationDoc,
                'nssf'              => $request->input('nssf'),
                'enddate'           => $request->input('enddate'),
                'phone'             => $request->input('phone'),
                'joining_date'      => $request->input('joining_date'),
                'start_date'        => $request->input('start_date'),
                'enddate'           => $request->input('end_date'),
                /// 'termination_letter' => $request->input('termination_letter'),
                /// 'contract_period'   => $request->input('contract_period'),
                'tin'               => $request->input('tin'),
                'nida'              => $request->input('nida')
            ];

            $data = array_merge($data, $additionalData);
        }

        User::create($data);

        $message = ($request->input('role_id') == 1) ? 'Admin created successfully!' : 'User created successfully!';
        return redirect()->back()->with('message', $message);
    }

    private function handleFileUpload($file, $path)
    {
        if ($file) {
            $filename = uniqid() . '.' . $file->getClientOriginalExtension();
            $file->storeAs($path, $filename);
            return $filename;
        }
        return null;
    }

    public function createUp(Request $request)
    {
        // Validation rules
        $request->validate([
            'name'     => 'required|string|max:255',
            'email'    => 'required|string|email|max:255|unique:users',
            'role_id'  => 'required|integer',
            'phone'    => 'required|string',
            'images'   => 'nullable|image|mimes:jpeg,png,jpg|max:2048',
            'joining_date' => 'required|date',
            'position' => 'required|string',
            'tin'      => 'nullable|string',
            'nida'     => 'nullable|string',
            'nssf'     => 'nullable|string',
            'status'   => 'required|string',
        ]);

        // Handle file uploads
        $imageName = $request->hasFile('images')
            ? time() . '.' . $request->file('images')->getClientOriginalExtension()
            : null;

        $cvDoc = $request->hasFile('cv')
            ? uniqid() . '.' . $request->file('cv')->getClientOriginalExtension()
            : null;

        $contractDoc = $request->hasFile('contract')
            ? uniqid() . '.' . $request->file('contract')->getClientOriginalExtension()
            : null;

        $applicationDoc = $request->hasFile('application')
            ? uniqid() . '.' . $request->file('application')->getClientOriginalExtension()
            : null;

        // Store files if uploaded
        if ($imageName) $request->file('images')->storeAs('public/images', $imageName);
        if ($cvDoc) $request->file('cv')->storeAs('public/upload', $cvDoc);
        if ($contractDoc) $request->file('contract')->storeAs('public/upload', $contractDoc);
        if ($applicationDoc) $request->file('application')->storeAs('public/upload', $applicationDoc);

        // Prepare user data
        $userData = [
            'name' => $request->input('name'),
            'email' => $request->input('email'),
            'password' => Hash::make($request->input('password')),
            'role_id' => $request->input('role_id'),
            'profile_image' => $imageName,
            'phone' => $request->input('phone'),
            'first_name' => $request->input('first_name'),
            'middle_name' => $request->input('middle_name'),
            'last_name' => $request->input('last_name'),
            'status' => $request->input('status'),
            'position' => $request->input('position'),
            'cv' => $cvDoc,
            'contract' => $contractDoc,
            'application' => $applicationDoc,
            'joining_date' => $request->input('joining_date'),
            'start_date' => $request->input('start_date'),
            'enddate' => $request->input('enddate'),
            'tin' => $request->input('tin'),
            'nida' => $request->input('nida'),
            'nssf' => $request->input('nssf'),
            'termination_date' => $request->input('termination_date'),
            'termination_letter' => $request->input('termination_letter'),
            'contract_period' => $request->input('contract_period'),
        ];

        // Create user
        User::create($userData);

        return redirect()->back()->with('message', 'User created successfully!');
    }
    public function Edit(Request $request, $id)
    {
        $request->validate([
            'name'     => 'required|string|max:255',
            'email'    => 'required|string|email|max:255|unique:users,email,' . $id,
            //'password' => 'required|min:8|confirmed',
            'role_id'  => 'required'
        ]);

        $user = User::find($id);

        if ($request->hasFile('images')) {
            $image     = $request->file('images');
            $imageName = time() . '.' . $image->getClientOriginalExtension();
            $image->storeAs('public/images', $imageName);
            $user->profile_image = $imageName;
        }

        if ($request->hasFile('cv')) {
            $cv    = $request->file('cv');
            $cvDoc = uniqid() . '.' . $cv->getClientOriginalExtension();
            $cv->storeAs('public/upload', $cvDoc);
            $user->cv  =   $cvDoc;
        }

        if ($request->hasFile('contract')) {
            $contract    = $request->file('contract');
            $contractDoc = uniqid() . '.' . $contract->getClientOriginalExtension();
            $contract->storeAs('public/upload', $contractDoc);
            $user->contract  =   $contractDoc;
        }

        if ($request->hasFile('application')) {
            $application    = $request->file('application');
            $applicationDoc = uniqid() . '.' . $application->getClientOriginalExtension();
            $application->storeAs('public/upload', $applicationDoc);
            $user->application  =   $applicationDoc;
        }


        if (!$user) {
            return redirect()->back()->with('error', 'User not found');
        }

        if ($request->input('role_id') === '1') {

            $user->update([
                'name'          =>   $request->input('name'),
                'email'         =>   $request->input('email'),
                'phone'         =>   $request->input('phone'),
                'role_id'       =>   $request->input('role_id'),

            ]);
            return redirect()->back()->with('message', 'Admin created successfully!');
        } else {
            $user->update([
                'name'              =>   $request->input('name'),
                'email'             =>   $request->input('email'),
                'role_id'           =>   $request->input('role_id'),
                'first_name'        =>   $request->input('first_name'),
                'middle_name'       =>   $request->input('middle_name'),
                'last_name'         =>   $request->input('last_name'),
                'status'            =>   $request->input('status'),
                'position'          =>   $request->input('position'),
                'nssf'              =>   $request->input('nssf'),
                'enddate'           =>   $request->input('enddate'),
                'phone'             =>   $request->input('phone'),
                'joining_date'      =>   $request->input('joining_date'),
                'start_date'        =>   $request->input('start_date'),
                'termination_date'  =>   $request->input('termination_date'),
                'termination_letter' =>   $request->input('termination_letter'),
                'contract_period'   =>   $request->input('contract_period'),
                'tin'               =>   $request->input('tin'),
                'nida'              =>   $request->input('nida')
            ]);
        }
        return redirect()->back()->with('message', 'Changes have been updated successfully!');
    }


    public function editAdmin($id)
    {
        $user  = User::find($id);
        return view('user.editadmin', compact('user'));
    }
    public function editAdminData(Request $request, $id)
    {
        $admin = User::find($id);
        $admin->update([
            'name'          =>   $request->input('name'),
            'email'         =>   $request->input('email'),
            'phone'         =>   $request->input('phone'),
            'role_id'       =>   $request->input('role_id'),
        ]);
        return redirect()->back()->with('message', 'Changes are updated successfully!');
    }
}
PK     ¨|[v@{hh  hh    TasksController.phpnu „[µü¤        <?php

namespace App\Http\Controllers;

use App\Models\Client;
use App\Models\ClientsService;
use App\Models\Tasks;
use App\Models\Employee;
use App\Models\KPI_Tracker;
use App\Models\Postcheck_Attachment;
use App\Models\Postchecks;
use App\Models\Precheck_Attachment;
use App\Models\Prechecks;
use App\Models\RecieveDoc;
use App\Models\Service;
use App\Models\Task_Comments;
use App\Models\Task_Post;
use App\Models\User;
use Carbon\Carbon;
use Exception;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Artisan;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\DB;
use PhpParser\Node\Expr\Empty_;
use Spatie\Permission\Contracts\Role as ContractsRole;
use Spatie\Permission\Models\Role;

class TasksController extends Controller
{
    public function taskjob(Request $request)
    {
        $role  = Role::find(Auth::user()->role_id);
        $user = Auth::user()->id;
        $tasks = Tasks::with('EachTask', 'clientservice', 'userAssign', 'juniorAssign', 'client')->get();

        //return view('task.tasks', compact('tasks'));
        if (Auth::user()->role_id < 2) {
            $tasks = Tasks::with('EachTask', 'clientservice.service', 'userAssign', 'juniorAssign', 'client')->get();
            //Tasks::with('client.clientserv.service', 'EachTask', 'userAssign', 'juniorAssign')->get();
            return view('task.tasks', compact('tasks'));
        } elseif (Auth::user()->role_id == 2 || Auth::user()->role_id == 3) {
            $tasks = Tasks::with('EachTask', 'clientservice.service', 'userAssign', 'juniorAssign', 'client')
                ->where('user_id', '=', $user)
                ->get();
            return view('task.tasks', compact('tasks'));
        } elseif (Auth::user()->role_id == 4) {
            $tasks = Tasks::with('EachTask', 'clientservice.service', 'userAssign', 'juniorAssign', 'client')
                ->where('junior_id', '=', $user)
                ->get();
            return view('task.tasks', compact('tasks'));
        } else {
            return false;
        }
    }
    public function notaskjob()
    {
        return view('task.notasks');
    }
    public function addemployee() {}

    public function create()
    {
        //$employees = Employee::all();
        $client = Client::all();
        $clientservice = ClientsService::all();
        $users = User::with('roleuser')->get();

        $role = Role::find(Auth::user()->role_id);
        if ($role->hasPermissionTo('task-add')) {
            return view('task.createTask', compact(['clientservice', 'client', 'users']));
        } else {
            return redirect()->route('error.403');
        }
    }

    public function storeTask(Request $request)
    {
        $task = new Tasks();

        $task->clients_id                            =    $request->clients_id;
        $task->user_id                               =    $request->employees;
        $task->clientservices_id                     =    $request->service;
        //$task->category                            =    $request->category;
        $task->start_date                            =    $request->start_date;
        $task->end_date                              =    $request->end_date;
        $task->job_date_documents_received_precheck  =    $request->job_date_documents_received_precheck;
        $task->job_kpi_enabled                       =    $request->job_kpi_enabled;
        $task->job_kpi_deadline_to_receive_document  =    $request->job_kpi_deadline_to_receive_document;
        $task->job_date_documents_receive            =    $request->job_date_documents_receive;
        $task->kpi_early_point                       =    $request->kpi_early_point;
        $task->kpi_late_point                        =    $request->kpi_late_point;
        $task->kpi_on_time_point                     =    "0";
        $task->task_target_day                      =    $request->task_target_days;
        $task->save();
        $taskId = $task->id;
        $userId = $task->user_id;
        //return response()->json($task);
        if ($task->job_kpi_enabled === 'Yes') {
            KPI_Tracker::create([
                'tasks_id'           => $taskId,
                'users_id'           => $userId,
                'kpi_early_point'    => $task->kpi_early_point,
                'kpi_late_point'     => $task->kpi_late_point,
                'kpi_on_time_point'  => "0",
                'task_target_day'    => $task->task_target_day,
                'created_at'         => now(),
                'updated_at'         => now(),
            ]);
            $task->save();
        }
        return redirect()->back()->with('message', 'Task created successfully');
    }

    public function receiveDoc($id)
    {
        return view('task.receivedoc');
    }

    public function documents($id)
    {
        $task = Tasks::with('client.clientserv.serv', 'employee')->find($id);
        return view('task.receivedoc', compact('task'));
    }
    public function receivedocStore(Request $request)
    {

        $receiveDoc = new RecieveDoc();
        $receiveDoc->task_id       =    $request->taskNo;
        $receiveDoc->client_id     =    $request->client;
        $receiveDoc->service_id    =    $request->service;
        $receiveDoc->dateReceived  =    $request->dateReceived;
        $receiveDoc->note          =    $request->note;
        $receiveDoc->quantity      =    $request->quantity;
        $receiveDoc->fileType      =    $request->fileType;
        $receiveDoc->narration     =    $request->narration;

        $receiveDoc->save();
        return redirect()->back()->with('message', 'Your successfully Receive Document!');
    }
    public function documentsstore($id)
    {
        return view('task.receivedoc');
    }
    public function updateview($id)
    {
        $tasks = Tasks::with('client.clientserv.serv', 'employee')->get();
        foreach ($tasks as $row) {
            return view('task.update', compact('row'));
        }
    }

    public function activate(Request $request) {}

    public function taskuser()
    {
        return view('task.tasksUser');
    }

    public function taskProg($id)
    {

        $taskpost = DB::table('task_post')->where('task_id', $id)->get();
        $approver = User::all();
        $mainPost = Task_Post::with('postuser')->where('task_id', $id)->orderBy('created_at', 'desc')->get();

        $comments        = Task_Comments::where('task_id', $id)->orderBy('created_at', 'desc')->get();
        $mainTask        = Tasks::with('client.clientserv.serv', 'clientservice.service', 'userAssign', 'juniorAssign')->find($id);
        $servId          = $mainTask->clientservice->service->id;

        $precheck        = Prechecks::where('service_id', $servId)->get();
        $postcheck       = Postchecks::where('service_id', $servId)->get();

        $precheckStatus  = Precheck_Attachment::where('task_id', $id)->first();
        $postcheckStatus = Postcheck_Attachment::where('task_id', $id)->first();

        //$precheckAttach  = Precheck_Attachment::where('task_id', $id)->get();
        $precheckAttach = Precheck_Attachment::where('task_id', $id)->get()->keyBy('serviceprecheck_id');
        $postcheckAttach = Postcheck_Attachment::where('task_id', $id)->get();

        $result = DB::table('precheck_attachment')
            ->join('service_prechecks', 'precheck_attachment.id', '=', 'service_prechecks.id')
            ->select('precheck_attachment.*', 'service_prechecks.*')
            ->where('precheck_attachment.task_id', '=', $id)
            //->where('service_id', $servId)
            ->get();
        ///Precheck Display
        $precheckRes1 = Prechecks::with([
            'attachments' => function ($query) use ($id) {
                $query->where('task_id', $id);
            }
        ])->where('service_id', $servId)->get();

        ///Postcheck Display
        $postcheckRes = Postchecks::with([
            'postattachments' => function ($query) use ($id) {
                $query->where('task_id', $id);
            }
        ])->where('service_id', $servId)->get();

        /*$precheck = DB::select("
            SELECT p.*, pa.precheck_attach, pa.task_id, pa.status
            FROM service_prechecks p LEFT JOIN precheck_attachment pa ON p.id = pa.serviceprecheck_id WHERE p.service_id = ?", [$servId]);*/

        /*$precheckRes = DB::table('service_prechecks as p')
            ->leftJoin('precheck_attachment as pa', function ($join) use ($id) {
                $join->on('p.id', '=', 'pa.serviceprecheck_id')
                    ->where('pa.task_id', '=', $id);
            })
            ->where('p.service_id', $servId)
            ->select('p.*', 'pa.precheck_attach', 'pa.task_id', 'pa.status')
            ->get();*/


        /*******---------- Retrive the data from Precheck_attactment Table --------************/
        $completePre  = DB::table('precheck_attachment')
            ->join('service_prechecks', 'precheck_attachment.id', '=', 'service_prechecks.id')
            ->select('precheck_attachment.*', 'service_prechecks.*')
            ->where('precheck_attachment.task_id', '=', $id)
            ->first();

        /*******---------- Retrive the data from Postcheck_attactment Table --------************/
        $completePost  = DB::table('postcheck_attachment')
            ->join('service_postchecks', 'postcheck_attachment.id', '=', 'service_postchecks.id')
            ->select('postcheck_attachment.*', 'service_postchecks.*')
            ->where('postcheck_attachment.task_id', '=', $id)
            ->first();
        foreach ($comments as $comment) {
            $commentTimestamp = $comment->created_at;
            // $timeDif = calculateTimeDifference($commentTimestamp);
        }
        //return response()->json($precheckRes1);
        return view('task.taskprogress', compact('mainTask', 'precheck', 'postcheck', 'completePre', 'completePost', 'mainPost', 'comments', 'precheckStatus', 'postcheckStatus', 'precheckRes1', 'postcheckRes'));
    }

    /********************* Pre Check Item One By One *******************/
    public function getTaskProgData($id)
    {
        $taskpost = DB::table('task_post')->where('task_id', $id)->get();
        $approver = User::all();
        $mainPost = Task_Post::with('postuser')->where('task_id', $id)->orderBy('created_at', 'desc')->get();
        $comments = Task_Comments::where('task_id', $id)->orderBy('created_at', 'desc')->get();
        $mainTask = Tasks::with('client.clientserv.serv', 'clientservice.service', 'userAssign', 'juniorAssign')->find($id);

        $servId = $mainTask->clientservice->service->id;
        $precheckRes1 = Prechecks::with(['attachments' => function ($query) use ($id) {
            $query->where('task_id', $id);
        }])->where('service_id', $servId)->get();

        $postcheckRes = Postchecks::with(['postattachments' => function ($query) use ($id) {
            $query->where('task_id', $id);
        }])->where('service_id', $servId)->get();

        return response()->json([
            'mainTask' => $mainTask,
            'precheckRes1' => $precheckRes1,
            'postcheckRes' => $postcheckRes,
            'mainPost' => $mainPost,
            'comments' => $comments,
        ]);
    }


    /********************* Pre Check Item One By One *******************/


    public function PreheckItem(Request $request, $id)
    {

        if ($request->hasFile('precheck_file')) {
            $file = $request->file('precheck_file');
            $fileName = uniqid() . '.' . $file->getClientOriginalExtension();
            $filePath = $file->storeAs('public/checklist', $fileName); // Store file
        } else {
            return back()->with('error', 'No file uploaded.');
        }
        $precheck = new Precheck_Attachment();
        $precheck->task_id              = $request->input('task_id');
        $precheck->serviceprecheck_id   = $request->input('precheck_id');
        $precheck->precheck_attach      = $fileName;
        $precheck->status               = 'yes';
        $precheck->save();
        return redirect()->back()->with('message', 'Your successfully upload document!');

        /*try {
            if ($request->hasFile('precheck_attach')) {
                $file = $request->file('precheck_attach');
                $pdfFileName = uniqid() . '.' . $file->getClientOriginalExtension();
                $file->storeAs('public/checklist', $pdfFileName);
            }
            $item = Precheck_Attachment::create([
                'task_id'            => $id,
                'precheck_attach'    => $pdfFileName,
                'serviceprecheck_id' => $request->input('precheck_id'),
                'status'             => $request->input('status')
            ]);
        } catch (Exception $e) {
            return response()->json(['error' => $e->getMessage()]);
        }*/
    }
    /********************* Update Pre Check Item One By One *******************/
    public function UpdatePreheckItem(Request $request, $id)
    {
        $updatePrecheck = Precheck_Attachment::find($id);
        if ($request->hasFile('precheck_file')) {
            $file = $request->file('precheck_file');
            $fileName = uniqid() . '.' . $file->getClientOriginalExtension();
            $filePath = $file->storeAs('public/checklist', $fileName); // Store file
        } else {
            return back()->with('error', 'No file uploaded.');
        }
        $updatePrecheck->precheck_attach      = $fileName;
        $updatePrecheck->status               = 'yes';
        $updatePrecheck->save();
        return redirect()->back()->with('message', 'Your successfully Update the document!');
    }

    /********************* Post Check Item One By One *******************/
    public function PostheckItem(Request $request, $id)
    {

        if ($request->hasFile('postcheck_attach')) {
            $file = $request->file('postcheck_attach');
            $fileName = uniqid() . '.' . $file->getClientOriginalExtension();
            $filePath = $file->storeAs('public/checklist', $fileName); // Store file
        } else {
            return back()->with('error', 'No file uploaded.');
        }
        $postcheck = new Postcheck_Attachment();
        $postcheck->task_id              = $request->input('task_id');
        $postcheck->servicepostcheck_id    = $request->input('postcheck_id');
        $postcheck->postcheck_attach      = $fileName;
        $postcheck->status               = 'yes';
        $postcheck->save();
        return redirect()->back()->with('message', 'Your successfully upload document!');
    }

    /********************* Update Post Check Item One By One *******************/
    public function UpdatePostheckItem(Request $request, $id)
    {
        $updatePostcheck = Postcheck_Attachment::find($id);
        if ($request->hasFile('postcheck_attach')) {
            $file = $request->file('postcheck_attach');
            $fileName = uniqid() . '.' . $file->getClientOriginalExtension();
            $filePath = $file->storeAs('public/checklist', $fileName); // Store file
        } else {
            return back()->with('error', 'No file uploaded.');
        }
        $updatePostcheck->postcheck_attach      = $fileName;
        $updatePostcheck->status               = 'yes';
        $updatePostcheck->save();
        return redirect()->back()->with('message', 'Your successfully Update the document!');
    }
    /********************* Time Different *******************/
    function calculateTimeDifference($commentTimestamp)
    {
        $currentTime = Carbon::now();
        $commentTime = Carbon::parse($commentTimestamp);

        $timeDifference = $commentTime->diffInSeconds($currentTime);

        if ($timeDifference < 60) {
            return $timeDifference . ' sec ago';
        } elseif ($timeDifference < 3600) {
            $minutes = round($timeDifference / 60);
            return $minutes . ' min ago';
        } elseif ($timeDifference < 86400) {
            $hours = round($timeDifference / 3600);
            return $hours . ' hr ago';
        } else {
            $days = round($timeDifference / 86400);
            return $days . ' days ago';
        }
    }

    public function approveTask(Request $request, $id)
    {
        $approveTask = Tasks::find($id);
        $approveTask->approve_status  =  $request->approve;
        $approveTask->update();
        return redirect()->back();
    }
    //approve pre checklist
    public function approvePreCheckTask(Request $request, $id)
    {
        $approveTask = Tasks::find($id);
        $approveTask->pre_approval  =  'yes';
        $approveTask->update();
        return redirect()->back()->with('message', 'Task Approved Successfully!');
    }

    //approve pre checklist
    public function approvePostCheckTask(Request $request, $id)
    {
        $approveTask = Tasks::find($id);
        $approveTask->post_approval  =  'yes';
        $approveTask->update();
        return redirect()->back()->with('message', 'Task Approved Successfully!');
    }
    /************** Complete Task ***********/
    public function completeTask($id)
    {
        $task = Tasks::find($id);
        $task->complete_task = 'yes';
        $task->update();
        return redirect()->back()->with('message', 'Task is Completed Successfully!');
    }

    /************** Suspend Taask ****************/
    public function suspendTask($id)
    {
        $task = Tasks::find($id);
        $task->suspend_task = 'yes';
        $task->update();
        return redirect()->back()->with('message', 'Task is Suspended Successfully!');
    }

    public function PostProcess(Request $request)
    {

        $data = Task_Post::create([
            'user_id'      =>  $request->user_id,
            'post'         =>  $request->taskPost,
            'task_id'      =>  $request->task_id,
            'postcheck_id'  =>  $request->postcheck_id
        ]);

        return redirect()->back();
    }
    public function PostFetchData()
    {
        $getdata = Task_Post::all();
        return response()->json($getdata);
    }
    public function Postdata()
    {
        //$mainPost = Task_Post::all();
        // dd($mainPost);
        //if (count($mainPost) > 0) {
        //    return response()->json($mainPost);
        //}
    }
    public function TaskPost(Request $request)
    {
        $taskpost = Task_Post::create([
            'user_id'     =>  Auth::User()->id,
            'post'        =>  $request->taskPost,
            'task_id'     =>  $request->task_id,
        ]);

        return redirect()->back()->with('taskpost', $taskpost);
    }
    public function taskpostview() {}
    public function commentsview()
    {
        return response(['success' => 'comment index!']);
    }
    /********* Add Comment *************/
    public function comments(Request $request)
    {
        $comment = $request->validate([
            'user_id' => 'required',
            'comments' => 'required',
            'taskpost_id' => 'required',
            'task_id'  => 'required'
        ]);
        Task_Comments::create($comment);
        return redirect()->back();
    }
    /*public function Precheck(Request $request, $id)
    {
        $status               = $request->input('status');
        $taskId               = $request->input('task_id');
        $precheck_id          = $request->input('precheck_id');
        $attachments          = $request->file('precheck_attach');
        if ($attachments) {
            foreach ($attachments as $index => $attachment) {
                $pdfFileName = uniqid() . '.' . $attachment->getClientOriginalExtension();
                $attachment->storeAs('public/checklist', $pdfFileName);
                Precheck_Attachment::create([
                    'precheck_attach'       => $pdfFileName,
                    'task_id'               => $taskId,
                    'serviceprecheck_id'    => $precheck_id[$index],
                    'status'                => $status[$index]
                ]);
            }
        }
        return redirect()->back()->with('message', 'Pre checklist was confirmed!');
    }*/

    /*public function CheckPrecheckAttach(Request $request, $id)
    {
        $status = Precheck_Attachment::findOrFail($id);

        $showViewUpdateBtn = ($status->status === 'yes');
        $showUploadBtn = ($status->status === 'no');
        return response()->json([
            'status'            => $status,
            'showViewUpdateBtn' => $showViewUpdateBtn,
            'showUploadBtn'     => $showUploadBtn
        ]);
    }*/
    public function CheckPrecheckAttach(Request $request, $id)
    {
        $PreCheckStatus = Precheck_Attachment::where('task_id', $id)->get();

        if ($PreCheckStatus->isEmpty()) {
            return response()->json(['error' => 'No attachments found'], 404);
        }

        return response()->json([
            'statuses' => $PreCheckStatus->map(function ($status) {
                return [
                    'id'                => $status->id,
                    'status'            => $status->status,
                    'showViewUpdateBtn' => $status->status === 'yes',
                    'showUploadBtn'     => $status->status === 'no',
                ];
            }),
        ]);
    }

    /********* Add Precheck *************/
    public function Precheck(Request $request, $id)
    {
        $request->validate([
            'precheck_attach' => 'required|mimes:pdf,doc,docx,xls,xlsx',
            'precheck_id' => 'required',
            'task_id' => 'required',
            'status' => 'required'
        ]);

        try {
            if ($request->hasFile('precheck_attach')) {
                $file = $request->file('precheck_attach');
                $pdfFileName = uniqid() . '.' . $file->getClientOriginalExtension();
                $file->storeAs('public/checklist', $pdfFileName);

                Precheck_Attachment::create([
                    'precheck_attach' => $pdfFileName,
                    'task_id' => $request->task_id,
                    'serviceprecheck_id' => $request->precheck_id,
                    'status' => $request->status
                ]);

                return response()->json(['message' => 'File uploaded successfully!'], 200);
            }
        } catch (\Exception $e) {
            return response()->json(['message' => 'File upload failed: ' . $e->getMessage()], 500);
        }

        return response()->json(['message' => 'No file uploaded.'], 400);
    }
    public function Postcheck(Request $request, $id)
    {
        $request->validate([
            'postcheck_attach' => 'required|mimes:pdf,doc,docx,xls,xlsx',
            'postcheck_id' => 'required',
            'task_id' => 'required',
            'status' => 'required'
        ]);

        try {
            if ($request->hasFile('postcheck_attach')) {
                $file = $request->file('postcheck_attach');
                $pdfFileName = uniqid() . '.' . $file->getClientOriginalExtension();
                $file->storeAs('public/checklist', $pdfFileName);

                Postcheck_Attachment::create([
                    'postcheck_attach' => $pdfFileName,
                    'task_id'           => $request->task_id,
                    'serviceprecheck_id' => $request->postcheck_id,
                    'status' => $request->status
                ]);

                return response()->json(['message' => 'File uploaded successfully!'], 200);
            }
        } catch (\Exception $e) {
            return response()->json(['message' => 'File upload failed: ' . $e->getMessage()], 500);
        }

        return response()->json(['message' => 'No file uploaded.'], 400);
    }
    /*public function Postcheck(Request $request, $id)
    {
        $status               = $request->input('status');
        $taskId               = $request->input('task_id');
        $postcheck_id         = $request->input('postcheck_id');
        $attachments          = $request->file('postcheck_attach');
        if ($attachments) {
            foreach ($attachments as $index => $attachment) {
                $pdfFileName = uniqid() . '.' . $attachment->getClientOriginalExtension();
                $attachment->storeAs('public/checklist', $pdfFileName);
                Postcheck_Attachment::create([
                    'postcheck_attach'      => $pdfFileName,
                    'task_id'               => $taskId,
                    'servicepostcheck_id'   => $postcheck_id[$index],
                    'status'                => $status[$index]
                ]);
            }
        }
        return redirect()->back()->with('message', 'Post checklist was confirmed!');
    }*/
    public function AssignJunior($id)
    {
        $junior  = User::with('roleuser')->get();

        $task = Tasks::with('client.clientservice.serv', 'userAssign')
            ->where('id', '=', $id)
            ->first();
        return view('task.assignjunior', compact('task', 'junior'));
    }
    public function AssignJuniorStoreData(Request $request, $id)
    {
        $task = Tasks::find($id);
        if ($task) {
            $task->junior_id   = $request->junior;
            $task->update();
        }
        return redirect()->back()->with('message', 'You assign task successfuly!');
    }
    public function ReassignSeniorIndex($id)
    {
        $senior = User::with('roleuser')->get();
        $task = Tasks::with('client.clientservice.serv', 'userAssign')
            ->where('id', '=', $id)
            ->first();
        return view('task.assignsenior', compact('task', 'senior'));
    }
    public function ReassignSenior(Request $request, $id)
    {
        $task = Tasks::find($id);
        if ($task) {
            $task->user_id = $request->senior;
            $task->update();
        }
        return redirect()->back()->with('message', 'You reassign senior staff to task successfuly!');
    }

    /*public function getTreeData()
    {
        // Example data structure representing years, months, services, and files
        $treeData = [
            ['id' => '2024', 'parent' => '#', 'text' => '2024'],
            ['id' => '2024-jan', 'parent' => '2024', 'text' => 'January'],
            ['id' => '2024-jan-service1', 'parent' => '2024-jan', 'text' => 'Payroll'],
            ['id' => '2024-jan-service1-file1', 'parent' => '2024-jan-service1', 'text' => 'File 1', 'state' => ['opened' => true]],
            ['id' => '2024-jan-service1-file2', 'parent' => '2024-jan-service1', 'text' => 'File 2', 'state' => ['opened' => true]],
            // Add more nodes as needed
        ];

        return response()->json($treeData);
    }*/
}
PK     ¨|[ãiÓp=  =    ReportController.phpnu „[µü¤        <?php

namespace App\Http\Controllers;

use App\Models\RecieveDoc;
use App\Models\Tasks;
use App\Models\User;
use Illuminate\Http\Request;

class ReportController extends Controller
{
    public function dailyreport()
    {
        return view('reports.daily');
    }
    public function  dailyreportData(Request $request)
    {
        $date = $request->input('daterepo');
        //$date = '2024-01-02';
        //$data = Tasks::whereRaw("DATE_FORMAT(created_at, '%m/%d/%y') = ?", $date)->first();
        $data = Tasks::whereDate('created_at', '=', date('Y-m-d', strtotime($date)))->first();
        return response()->json($data);
    }


    public function taskReport()
    {
        return view('reports.tasks_report');
    }
    public function checkListReport()
    {
        return view('reports.checklist_report');
    }
    public function checkListReportStore(Request $request)
    {
        $request->validate([
            'start_date' => 'required|date',
            'end_date' => 'required|date|after_or_equal:from_date',
        ]);

        // Retrieve data based on dates
        $fromDate = $request->input('start_date');
        $toDate = $request->input('end_date');

        // Query data using the model
        $data = RecieveDoc::whereBetween('created_by', [$fromDate, $toDate])
            ->get();

        return response()->json($data);
    }
    public function kpiReport()
    {
        return view('reports.kpi_report');
    }
    public function documentReceived()
    {
        return view('reports.receive_doc_report');
    }
    public function docReceivedStore(Request $request)
    {
        $request->validate([
            'daterange' => 'required|string',
            'module'    => 'required|string',
        ]);

        $dateRange = explode(' - ', $request->input('daterange'));
        $startDate = \Carbon\Carbon::createFromFormat('m/d/Y', $dateRange[0])->startOfDay();
        $endDate   = \Carbon\Carbon::createFromFormat('m/d/Y', $dateRange[1])->endOfDay();
        $module    = $request->module;

        if ($module === 'tasks') {
            $tasks = Tasks::whereBetween('created_at', [$startDate, $endDate])->get();
        } elseif ($module === 'kpi') {
            // Replace 'Kpi' with your actual model for KPI
            //$tasks = Kpi::whereBetween('created_at', [$startDate, $endDate])->get();
        } else {
            return redirect()->back()->withErrors(['Invalid module selected']);
        }

        return view('reports.receive_doc_report', compact('tasks'));
    }
    public function presetReport()
    {
        $users =  User::all();
        return view('reports.preset_report', compact('users'));
    }
    public function presetReportStore(Request $request)
    {
        $period     = $request->period;
        $user       = $request->userId;
        $module    = $request->module;
        if ($module == 'tasks') {
        }

        return view('reports.receive_doc_report', compact('data'));
    }
    public function customReport()
    {
        return view('reports.custom_report');
    }
    public function customReportStore(Request $request)
    {
        $module    = $request->module;
        $date      = $request->input('daterange');
        $dateRange = explode(' - ', $date);
        $startDate = \Carbon\Carbon::createFromFormat('m/d/Y', $dateRange[0])->startOfDay();
        $endDate   = \Carbon\Carbon::createFromFormat('m/d/Y', $dateRange[1])->endOfDay();

        if ($module == "tasks") {
            $data = Tasks::whereBetween('created_at', [$startDate, $endDate])->get();
            return view('reports.custom_report', compact('data'));
        } else {
            return redirect()->back()->with('error', 'Invalid Module Selected!');
        }


        /*
        $startDate = \Carbon\Carbon::createFromFormat('m/d/Y', $dateRange[0])->startOfDay();
        $endDate   = \Carbon\Carbon::createFromFormat('m/d/Y', $dateRange[1])->endOfDay();
        $module    = $request->module;

        if ($module === 'tasks') {
            $data = Tasks::whereBetween('created_at', [$startDate, $endDate])->get();
        } elseif ($module === 'kpi') {
            // Replace 'Kpi' with your actual model for KPI
            //$tasks = Kpi::whereBetween('created_at', [$startDate, $endDate])->get();
        } else {
            return redirect()->back()->withErrors(['Invalid module selected']);
        }*/
    }
}
PK     ¨|[ÿŠç­6  6    ModuleController.phpnu „[µü¤        <?php

namespace App\Http\Controllers;

use App\Models\module;
use App\Models\ModuleSetting;
use Illuminate\Http\Request;

class ModuleController extends Controller
{
    public function moduleSetting()
    {
        ///  $setting = ModuleSetting::all();
        return view('settings.modulesetting');
    }
}
PK       ¨|[óZMï~
  ~
                  DispatchJobController.phpnu „[µü¤        PK       ¨|[fdê                Ç
  ClientsServiceController.phpnu „[µü¤        PK       ¨|[qÓïžÇ
  Ç
                TemplateController.phpnu „[µü¤        PK       ¨|[w¥Ät  t              +  PortalPasswrdController.phpnu „[µü¤        PK       ¨|[BÍ‹­Í  Í              ê)  HrmController.phpnu „[µü¤        PK       ¨|[§5Þ  Þ              ø<  PusherController.phpnu „[µü¤        PK       ¨|[tîŽ  Ž              @  Controller.phpnu „[µü¤        PK       ¨|[í8>Ø  Ø              æA  PolicyController.phpnu „[µü¤        PK       ¨|[ÌÛ=Î+   +               F  ServiceController.phpnu „[µü¤        PK       ¨|[5Ô–ˆ;  ;              rf  GeneralSettingController.phpnu „[µü¤        PK       ¨|[Ÿº#í—;  —;              ùt  HomeController.phpnu „[µü¤        PK       ¨|[B“.…¯R  ¯R              Ò°  RolePermissionController.phpnu „[µü¤        PK       ¨|[ðX†É•  •              Í ClientController.phpnu „[µü¤        PK       ¨|[ójR¸  ¸              ¡™ EmployeeController.phpnu „[µü¤        PK       ¨|[KÞÿW  ÿW              Ÿ° ContactPersonController.phpnu „[µü¤        PK       ¨|[fs>¯  ¯               é Auth/ResetPasswordController.phpnu „[µü¤        PK       ¨|[‚ðKº›  ›  !            è Auth/ForgotPasswordController.phpnu „[µü¤        PK       ¨|[ä÷„[      "            Ô Auth/ConfirmPasswordController.phpnu „[µü¤        PK       ¨|[gkHoê  ê              & Auth/LoginController.phpnu „[µü¤        PK       ¨|[î-¬“j  j              X Auth/VerificationController.phpnu „[µü¤        PK       ¨|[6Sÿë                 Auth/RegisterController.phpnu „[µü¤        PK       ¨|[k®±˜}  }              q' PDFController.phpnu „[µü¤        PK       ¨|[©dŒâ	  â	              /A UserController.phpnu „[µü¤        PK       ¨|[¿“¦ýS  S              SK ErrorLog.phpnu „[µü¤        PK       ¨|[-îý÷Y  Y              âL ProfileSettingController.phpnu „[µü¤        PK       ¨|[V5µ	  µ	              ‡Q RemindersController.phpnu „[µü¤        PK       ¨|[æù/¤8  ¤8              ƒ[ RegController.phpnu „[µü¤        PK       ¨|[v@{hh  hh              h” TasksController.phpnu „[µü¤        PK       ¨|[ãiÓp=  =              ý ReportController.phpnu „[µü¤        PK       ¨|[ÿŠç­6  6              ” ModuleController.phpnu „[µü¤        PK      4
     