FM / Controllers

/home/u417168693/domains/devtechera.com/public_html/app/Controllers/

/home/u417168693/domains/devtechera.com/public_html/app/Controllers

Name	Size	Mode	Actions
Admin.php	61423	0644	edit dl rm
BaseController.php	1586	0644	edit dl rm
Home.php	14402	0644	edit dl rm

Edit: /home/u417168693/domains/devtechera.com/public_html/app/Controllers/Admin.php (61423B)

<?php

namespace App\Controllers;

use App\Models\AdminModel;
use App\Models\BlogModel;
use App\Models\EnquiryModel;
use App\Models\FaqModel;
use App\Models\PageModel;
use App\Models\PortfolioModel;
use App\Models\RedirectionModel;
use App\Models\ServiceModel;
use App\Models\SitemapModel;
use App\Models\TeamModel;
use CodeIgniter\Validation\Validation;

class Admin extends BaseController
{
    public function __construct()
    {
        error_reporting(E_ALL);
        ini_set('display_errors', 1);
        date_default_timezone_set(timezoneId: 'Asia/Kolkata');
    }

public function login()
    {
        if (session()->has('admin_email')) {
            return redirect()->to(base_url("admin"));
        }
        return view("/admin/login");
    }

public function loginProcess()
    {
        $validation = \Config\Services::validation();
        $validation->setRules([
            'email' => 'required|valid_email',
            'password' => 'required',
        ]);

$email = $this->request->getPost("email");
        $password = $this->request->getPost("password");
        $data = [
            'email' => $email,
            'password' => $password,
        ];

if ($validation->run($data)) {
            $adminModel = new AdminModel();
            $res = $adminModel->where("email", $email)->first();

if ($res) {
                if (md5($password) == $res['password']) {
                    session()->set('admin_email', $res['email']);
                    session()->set('admin_name', $res['name']);
                    session()->set('admin_username', $res['username']);

session()->setFlashdata('message', 'Login Successful!');
                    session()->setFlashdata('message_class', 'success');
                    return redirect()->to(base_url('admin/'));
                } else {
                    session()->setFlashdata('message', 'Incorrect password!');
                    session()->setFlashdata('message_class', 'danger');
                    return view("admin/login", ['formData' => $data]);
                }
            } else {
                session()->setFlashdata('message', 'No account found with this email!');
                session()->setFlashdata('message_class', 'danger');
                return view("admin/login", ['formData' => $data]);
            }
        } else {
            return view("admin/login", ['errors' => $validation->getErrors(), 'formData' => $data]);
        }
    }

public function logout()
    {
        session()->destroy();
        return redirect("admin/login");
    }

public function index()
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $EnqModel = new EnquiryModel();
        $enqCount = $EnqModel->countAllResults();

$BlogModel = new BlogModel();
        $blogCount = $BlogModel->countAllResults();

$PageModel = new PageModel();
        $pageCount = $PageModel->countAllResults();

$ServiceModel = new ServiceModel();
        $serviceCount = $ServiceModel->countAllResults();

$teamModel = new TeamModel();
        $teamCount = $teamModel->countAllResults();

return view("admin/index", ['enqCount' => $enqCount, 'blogCount' => $blogCount, 'pageCount' => $pageCount, 'serviceCount' => $serviceCount, 'teamCount' => $teamCount]);
    }

public function enquiries()
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $EnqModel = new EnquiryModel();
        $EnqModel->select('dte_enquiry.*, dte_service.service_name');
        $EnqModel->join('dte_service', 'dte_service.id = dte_enquiry.service', 'left');
        $enq = $EnqModel->findAll();
        return view("admin/enquiries", ['enquiries' => $enq]);
    }
    public function deleteEnquiry($enqId)
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $EnqModel = new EnquiryModel();
        if ($EnqModel->delete($enqId)) {
            session()->setFlashdata('message', 'Enquiry deleted successfully!');
            session()->setFlashdata('message_class', 'success');
            return redirect("admin/enquiries");
        } else {
            session()->setFlashdata('message', 'Enquiry could not be deleted!');
            session()->setFlashdata('message_class', 'danger');
            return redirect("admin/enquiries");
        }
    }
    public function addEnquiry()
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $serviceModel = new ServiceModel();
        $serviceModel->where('status', 1);
        $services = $serviceModel->findAll();
        return view("admin/add-enquiry", ['services' => $services]);
    }
    public function addEnquiryProcess()
    {
        // error_reporting(E_ALL);
        // ini_set('display_errors', 1);
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }

$validation = \Config\Services::validation();
        $data = [
            'name' => $this->request->getPost('name'),
            'phone' => $this->request->getPost('phone'),
            'email' => $this->request->getPost('email'),
            'service' => $this->request->getPost('service'),
            'address' => $this->request->getPost('address'),
            'message' => $this->request->getPost('message'),
            'create_date' => date("d-m-Y : h:i A"),
            "status" => $this->request->getPost('status') ?: 2,
        ];
        $validation->setRules([
            'name' => 'required|min_length[3]|max_length[100]',
            'phone' => 'required|regex_match[/^[0-9]{10}$/]',
            'email' => 'required|valid_email',
            'address' => 'required|max_length[255]',
        ]);
        $serviceModel = new ServiceModel();
        $serviceModel->where('status', 1);
        $services = $serviceModel->findAll();
        if ($validation->run($data)) {
            $EnqModel = new EnquiryModel();
            $insert = $EnqModel->insert($data);
            if ($insert) {
                session()->setFlashdata('message', 'Enquiry submitted successfully!');
                session()->setFlashdata('message_class', 'success');
                return redirect("admin/enquiries");
            } else {
                session()->setFlashdata('message', 'Enquiry submitted successfully!');
                session()->setFlashdata('message_class', 'success');
                return view('admin/add-enquiry', ['errors' => $validation->getErrors(), 'services' => $services, 'formData' => $data,]);
            }
        } else {
            return view('admin/add-enquiry', ['errors' => $validation->getErrors(), 'services' => $services, 'formData' => $data,]);
        }
    }

public function updateEnquiry($enqId)
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $EnqModel = new EnquiryModel();
        $data = $EnqModel->find($enqId);

$serviceModel = new ServiceModel();
        $serviceModel->where('status', 1);
        $services = $serviceModel->findAll();

return view("admin/update-enquiry", ['enquiry' => $data, 'services' => $services]);
    }

public function updateEnquiryProcess()
    {
        // error_reporting(E_ALL);
        // ini_set('display_errors', 1);
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $enqId = $this->request->getPost('enqId');
        if (empty($enqId)) {
            return redirect("admin/enquiries");
        }
        $validation = \Config\Services::validation();
        $data = [
            'name' => $this->request->getPost('name'),
            'phone' => $this->request->getPost('phone'),
            'email' => $this->request->getPost('email'),
            'service' => $this->request->getPost('service'),
            'address' => $this->request->getPost('address'),
            'message' => $this->request->getPost('message'),
            'update_date' => date("d-m-Y : h:i A"),
            "status" => $this->request->getPost('status') ?: 2,
        ];
        $validation->setRules([
            'name' => 'required|min_length[3]|max_length[100]',
            'phone' => 'required|regex_match[/^[0-9]{10}$/]',
            'email' => 'required|valid_email',
            'address' => 'required|max_length[255]',
        ]);

$serviceModel = new ServiceModel();
        $serviceModel->where('status', 1);
        $services = $serviceModel->findAll();

if ($validation->run($data)) {
            $data['enqId'] = $enqId;
            $EnqModel = new EnquiryModel();
            $EnqModel->set($data);
            $EnqModel->where('id', $enqId);
            $update = $EnqModel->update();
            if ($update) {
                session()->setFlashdata('message', 'Enquiry updated successfully!');
                session()->setFlashdata('message_class', 'success');
                return redirect("admin/enquiries");
            } else {
                session()->setFlashdata('message', 'Enquiry could not be updated!');
                session()->setFlashdata('message_class', 'success');
                return view('admin/update-enquiry', ['errors' => $validation->getErrors(), 'services' => $services, 'formData' => $data,]);
            }
        } else {
            $data['enqId'] = $enqId;
            return view('admin/update-enquiry', ['errors' => $validation->getErrors(), 'services' => $services, 'formData' => $data,]);
        }
    }

public function add_blog()
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $serviceModel = new ServiceModel();
        $serviceModel->where('status', 1);
        $services = $serviceModel->findAll();
        return view("admin/add-blog", ['services' => $services]);
    }

public function blogs()
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $blogModel = new BlogModel();
        $blogs = $blogModel->orderBy('id','DESC')->findAll();
        return view("admin/blogs", ['blogs' => $blogs]);
    }

public function add_blog_process()
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $serviceModel = new ServiceModel();
        $serviceModel->where('status', 1);
        $services = $serviceModel->findAll();
        
        
        $blogModel = new BlogModel();
        $validation = \Config\Services::validation();
        $validation->setRules([
            'slug' => 'required',
            'title' => 'required',
            'description' => 'required',
            'short_description' => 'required',
        ]);

$slug = $this->request->getPost('slug');
        $count = $blogModel->where(['slug' => $slug])->countAllResults();

if ($count !== 0) {
            do {
                $slug = $slug . '-' . rand(1, 9);
                $count = $blogModel->where(['slug' => $slug])->countAllResults();
            } while ($count !== 0);
        }

$data = [
            "slug" => $slug,
            "title" => $this->request->getPost('title'),
            "short_description" => $this->request->getPost('short_description'),
            "description" => $this->request->getPost('description'),
            "category" => $this->request->getPost('category'),
            "tags" => $this->request->getPost('tags'),
            "author" => "Devtechera Admin",
            "create_date" => date("d-m-Y : h:i:s"),
            "status" => $this->request->getPost('status') ?: 2,
        ];
        if ($validation->run($data)) {

$file = $this->request->getFile('feature_image');
            $checkFile = $file->getName();
            if (isset($checkFile) && !empty($checkFile)) {
                $uploadPath = 'public/blog_uploads/feature_image/';
                $fileName = $file->getRandomName();
                if ($file->isValid() && !$file->hasMoved()) {
                    $file->move($uploadPath, $fileName);
                    // $site_url = base_url('public/blog_uploads/feature_image/');
                    // $data['feature_image'] = $site_url . $fileName;
                    $data['feature_image'] = $fileName;
                }
            } else {
                $data['feature_image'] = "";
            }

$insert = $blogModel->insert($data);
            if ($insert) {
                $sitemapModel = new SitemapModel();
                $sitemap = [
                    "slug" => $slug,
                    "page_id" => '',
                    "blog_id" => $insert,
                    "create_date" => date("d-m-Y : h:i A"),
                    "status" => $this->request->getPost('status') ?: 2,
                ];
                $insert = $sitemapModel->insert($sitemap);
                session()->setFlashdata('message', 'Blog added successfully!');
                session()->setFlashdata('message_class', 'success');
                return redirect("admin/blogs");
            } else {
                session()->setFlashdata('message', 'Something went wrong - Blog could not be added!');
                session()->setFlashdata('message_class', 'danger');
                return view("admin/add-blog", ['formData' => $data]);
            }
        } else {
            return view("admin/add-blog", ['errors' => $validation->getErrors(), 'formData' => $data,'services' => $services]);
        }
    }

public function update_blog($blogId)
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $blogModel = new BlogModel();
        $blogDetails = $blogModel->find($blogId);
        $serviceModel = new ServiceModel();
        $serviceModel->where('status', 1);
        $services = $serviceModel->findAll();
        return view("admin/update-blogs", ['blog' => $blogDetails, 'services' => $services]);
    }

public function update_blog_process($blogId)
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $blogModel = new BlogModel();
        $blogDetails = $blogModel->find($blogId);

if (!$blogDetails) {
            session()->setFlashdata('message', 'Blog not found!');
            session()->setFlashdata('message_class', 'danger');
            return redirect()->to('/admin/blogs');
        }

// Validation rules for blog update
        $validation = \Config\Services::validation();
        $validation->setRules([
            "slug" => 'required',
            'title' => 'required',
            'description' => 'required',
            'short_description' => 'required',
        ]);

$slug = $this->request->getPost('slug');
        $count = $blogModel->where(['slug' => $slug, 'id !=' => $blogId])->countAllResults();

if ($count !== 0) {
            do {
                $slug = $slug . '-' . rand(1, 9);
                $count = $blogModel->where(['slug' => $slug, 'id !=' => $blogId])->countAllResults();
            } while ($count !== 0);
        }

$data = [
            "slug" => $slug,
            "title" => $this->request->getPost('title'),
            "short_description" => $this->request->getPost('short_description'),
            "description" => $this->request->getPost('description'),
            "category" => $this->request->getPost('category'),
            "tags" => $this->request->getPost('tags'),
            "update_date" => date("d-m-Y : h:i  A"),
            "status" => $this->request->getPost('status') ?: 2,
        ];

if ($validation->run($data)) {
            $file = $this->request->getFile('feature_image');
            if ($file && $file->isValid() && !$file->hasMoved()) {
                $uploadPath = 'public/blog_uploads/feature_image/';
                $fileName = $file->getRandomName();
                $file->move($uploadPath, $fileName);

// Store the new image filename
                $data['feature_image'] = $fileName;
            } else {
                // If no new file uploaded, keep the current feature image (if any)
                if (empty($data['feature_image'])) {
                    $data['feature_image'] = $blogDetails['feature_image'];
                }
            }

// Update blog in the database
            $blogModel->set($data);
            $blogModel->where('id', $blogId);
            $update = $blogModel->update();

// Check if the update was successful
            if ($update) {
                $sitemapModel = new SitemapModel();
                if($sitemapModel->where('blog_id',$blogId)->find()){
                    $sitemap = [
                    "slug" => $slug,
                    "page_id" => '',
                    "blog_id" => $blogId,
                    "update_date" => date("d-m-Y : h:i A"),
                    "status" => $this->request->getPost('status') ?: 2,
                ];
                $sitemapModel->set($sitemap)->where('blog_id',$blogId)->update();
            }else{
                $sitemap = [
                    "slug" => $slug,
                    "page_id" => '',
                    "blog_id" => $blogId,
                    "create_date" => date("d-m-Y : h:i A"),
                    "status" => $this->request->getPost('status') ?: 2,
                ];
                $sitemapModel->insert($sitemap);
            }

session()->setFlashdata('message', 'Blog updated successfully!');
                session()->setFlashdata('message_class', 'success');
                return redirect("admin/blogs");
            } else {
                session()->setFlashdata('message', 'Something went wrong - Blog could not be updated!');
                session()->setFlashdata('message_class', 'danger');
                return view("admin/update-blogs", ['errors' => $validation->getErrors(), 'formData' => $data, 'blog' => $blogDetails]);
            }
        } else {
            // If validation fails, return to the update form with errors
            return view("admin/update-blogs", ['errors' => $validation->getErrors(), 'formData' => $data, 'blog' => $blogDetails]);
        }
    }

public function pages()
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $pageModel = new PageModel();
        $pages = $pageModel->findAll();
        return view("admin/pages", ['pages' => $pages]);
    }
    public function add_page()
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        return view("admin/add_page");
    }
    public function add_page_process()
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $pageModel = new PageModel();
        $validation = \Config\Services::validation();
        $validation->setRules([
            'slug' => 'required',
            'page_name' => 'required',
            'page_title' => 'required',
            'page_content' => 'required',
        ]);

$slug = $this->request->getPost('slug');
        $count = $pageModel->where(['slug' => $slug])->countAllResults();

if ($count !== 0) {
            do {
                $slug = $slug . '-' . rand(1, 9);
                $count = $pageModel->where(['slug' => $slug])->countAllResults();
            } while ($count !== 0);
        }

$data = [
            "slug" => $slug,
            "page_name" => $this->request->getPost('page_name'),
            "page_title" => $this->request->getPost('page_title'),
            "page_content" => $this->request->getPost('page_content'),
            "category" => $this->request->getPost('category'),
            "meta_tags" => $this->request->getPost('meta_tags'),
            "create_date" => date("d-m-Y : h:i:s"),
            "status" => $this->request->getPost('status') ?: 2,
        ];
        if ($validation->run($data)) {

$file = $this->request->getFile('feature_image');
            $checkFile = $file->getName();
            if (isset($checkFile) && !empty($checkFile)) {
                $uploadPath = 'public/assets/page_image/';
                $fileName = $file->getRandomName();
                if ($file->isValid() && !$file->hasMoved()) {
                    $file->move($uploadPath, $fileName);
                    // $site_url = base_url('public/blog_uploads/feature_image/');
                    // $data['feature_image'] = $site_url . $fileName;
                    $data['feature_image'] = $fileName;
                }
            } else {
                $data['feature_image'] = "";
            }

$insert = $pageModel->insert($data);
            if ($insert) {
                $sitemapModel = new SitemapModel();
                $sitemap = [
                    "slug" => $slug,
                    "page_id" => $insert,
                    "blog_id" => '',
                    "create_date" => date("d-m-Y : h:i A"),
                    "status" => $this->request->getPost('status') ?: 2,
                ];
                $insert = $sitemapModel->insert($sitemap);
                session()->setFlashdata('message', 'Page added successfully!');
                session()->setFlashdata('message_class', 'success');
                return redirect("admin/pages");
            } else {
                session()->setFlashdata('message', 'Something went wrong - page could not be added!');
                session()->setFlashdata('message_class', 'danger');
                return view("admin/add_page", ['formData' => $data]);
            }
        } else {
            return view("admin/add_page", ['errors' => $validation->getErrors(), 'formData' => $data,]);
        }
    }
    public function update_page($pageId)
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $pageModel = new PageModel();
        $pageDetails = $pageModel->find($pageId);
        return view("admin/update-page", ['page' => $pageDetails]);
    }
    public function update_page_process($pageId)
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $pageModel = new PageModel();
        $pageDetails = $pageModel->find($pageId);

if (!$pageDetails) {
            session()->setFlashdata('message', 'Page not found!');
            session()->setFlashdata('message_class', 'danger');
            return redirect()->to('/admin/pages');
        }

// Validation rules for blog update
        $validation = \Config\Services::validation();
        $validation->setRules([
            'slug' => 'required',
            'page_name' => 'required',
            'page_title' => 'required',
            'page_content' => 'required',
        ]);

$slug = $this->request->getPost('slug');
        $count = $pageModel->where(['slug' => $slug, 'id !=' => $pageId])->countAllResults();

if ($count !== 0) {
            do {
                $slug = $slug . '-' . rand(1, 9);
                $count = $pageModel->where(['slug' => $slug, 'id !=' => $pageId])->countAllResults();
            } while ($count !== 0);
        }
        $data = [
            "slug" => $slug,
            "page_name" => $this->request->getPost('page_name'),
            "page_title" => $this->request->getPost('page_title'),
            "page_content" => $this->request->getPost('page_content'),
            "category" => $this->request->getPost('category'),
            "meta_tags" => $this->request->getPost('meta_tags'),
            "update_date" => date("d-m-Y : h:i A"),
            "status" => $this->request->getPost('status') ?: 2,
        ];

if ($validation->run($data)) {
            $file = $this->request->getFile('feature_image');
            if ($file && $file->isValid() && !$file->hasMoved()) {
                $uploadPath = 'public/assets/page_image/';
                $fileName = $file->getRandomName();
                $file->move($uploadPath, $fileName);

// Store the new image filename
                $data['feature_image'] = $fileName;
            } else {
                // If no new file uploaded, keep the current feature image (if any)
                if (empty($data['feature_image'])) {
                    $data['feature_image'] = $pageDetails['feature_image'];
                }
            }

// Update blog in the database
            $pageModel->set($data);
            $pageModel->where('id', $pageId);
            $update = $pageModel->update();

// Check if the update was successful
            if ($update) {
                $sitemapModel = new SitemapModel();
                if($sitemapModel->where('page_id',$pageId)->find()){
                    $sitemap = [
                    "slug" => $slug,
                    "page_id" => $pageId,
                    "blog_id" => '',
                    "update_date" => date("d-m-Y : h:i A"),
                    "status" => $this->request->getPost('status') ?: 2,
                ];
                $sitemapModel->set($sitemap)->where('page_id',$pageId)->update();
            }else{
                $sitemap = [
                    "slug" => $slug,
                    "page_id" => $pageId,
                    "blog_id" => '',
                    "create_date" => date("d-m-Y : h:i A"),
                    "status" => $this->request->getPost('status') ?: 2,
                ];
                $sitemapModel->insert($sitemap);
            }
                session()->setFlashdata('message', 'Page updated successfully!');
                session()->setFlashdata('message_class', 'success');
                return redirect("admin/pages");
            } else {
                session()->setFlashdata('message', 'Something went wrong - Page could not be updated!');
                session()->setFlashdata('message_class', 'danger');
                return view("admin/update-page", ['errors' => $validation->getErrors(), 'formData' => $data, 'page' => $pageDetails]);
            }
        } else {
            // If validation fails, return to the update form with errors
            return view("admin/update-page", ['errors' => $validation->getErrors(), 'formData' => $data, 'page' => $pageDetails]);
        }
    }

public function faq($pageId)
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $FaqModel = new FaqModel();
        $PageModel = new PageModel();
        $page = $PageModel->find($pageId);
        $FaqModel->where('page_id', $pageId);
        $faq = $FaqModel->findAll();
        return view("admin/faq", ['pageId' => $pageId, 'page' => $page, 'faqs' => $faq]);
    }

public function addFaq($pageId)
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        return view("admin/add-faq", ['pageId' => $pageId]);
    }

public function addFaqProcess()
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        // if (empty($this->request->getPost('page_id'))) {
        //     return redirect("admin/pages");
        // }
        $validation = \Config\Services::validation();
        $validation->setRules([
            'page_id' => 'required',
            'question' => 'required',
            'answer' => 'required',
        ]);

$data = [
            "page_id" => $this->request->getPost('page_id'),
            "question" => $this->request->getPost('question'),
            "answer" => $this->request->getPost('answer'),
            "create_date" => date("d-m-Y : h:i:s"),
            "status" => $this->request->getPost('status') ?: 2,
        ];
        if ($validation->run($data)) {

$FaqModel = new FaqModel();
            $insert = $FaqModel->insert($data);
            if ($insert) {
                session()->setFlashdata('message', 'FAQ added successfully!');
                session()->setFlashdata('message_class', 'success');
                // return redirect("admin/faq/" . $this->request->getPost('page_id'));
                return redirect()->to('/admin/faq/' . $this->request->getPost('page_id'));
            } else {
                session()->setFlashdata('message', 'Something went wrong - FAQ could not be added!');
                session()->setFlashdata('message_class', 'danger');
                return view("admin/addFaq", ['errors' => $validation->getErrors(), 'formData' => $data]);
            }
        } else {
            return view("admin/addFaq", ['errors' => $validation->getErrors(), 'formData' => $data]);
        }
    }

public function updateFaq($faqId)
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $FaqModel = new FaqModel();
        $faq = $FaqModel->find($faqId);
        return view("admin/update-faq", ['faq' => $faq]);
    }
    public function updateFaqProcess()
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $faqId = $this->request->getPost('id');
        if (empty($faqId)) {
            return redirect("admin/pages");
        }
        $validation = \Config\Services::validation();
        $validation->setRules([
            'page_id' => 'required',
            'question' => 'required',
            'answer' => 'required',
        ]);

$data = [
            "page_id" => $this->request->getPost('page_id'),
            "question" => $this->request->getPost('question'),
            "answer" => $this->request->getPost('answer'),
            "update_date" => date("d-m-Y : h:i A"),
            "status" => $this->request->getPost('status') ?: 2,
        ];
        if ($validation->run($data)) {

$FaqModel = new FaqModel();
            $FaqModel->set($data);
            $FaqModel->where('id', $faqId);
            $update = $FaqModel->update();
            if ($update) {
                session()->setFlashdata('message', 'FAQ updated successfully!');
                session()->setFlashdata('message_class', 'success');
                // return redirect("admin/faq/" . $this->request->getPost('page_id'));
                return redirect()->to('/admin/faq/' . $this->request->getPost('page_id'));
            } else {
                $data['id'] = $faqId;
                session()->setFlashdata('message', 'Something went wrong - FAQ could not be updated!');
                session()->setFlashdata('message_class', 'danger');
                return view("admin/update-faq", ['errors' => $validation->getErrors(), 'formData' => $data]);
            }
        } else {
            $data['id'] = $faqId;
            return view("admin/update-faq", ['errors' => $validation->getErrors(), 'formData' => $data]);
        }
    }

public function deleteFaq($pageId, $faqId)
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        if (empty($faqId) && empty($pageId)) {
            return redirect("admin/pages");
        }
        $faqModel = new FaqModel();
        if ($faqModel->delete($faqId)) {
            session()->setFlashdata('message', 'FAQ deleted successfully!');
            session()->setFlashdata('message_class', 'success');
            return redirect()->to('/admin/faq/' . $pageId);
        } else {
            $data['id'] = $faqId;
            session()->setFlashdata('message', 'FAQ could not be deleted!');
            session()->setFlashdata('message_class', 'danger');
            return redirect()->to('/admin/faq/' . $pageId);
        }
    }

public function services()
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $ServiceModel = new ServiceModel();
        $services = $ServiceModel->findAll();
        return view("admin/services", ['services' => $services]);
    }

public function addService()
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        return view("admin/add-service");
    }
    public function addServiceProcess()
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $validation = \Config\Services::validation();
        $validation->setRules([
            'service_name' => 'required',
        ]);

$data = [
            "service_name" => $this->request->getPost('service_name'),
            "create_date" => date("d-m-Y : h:i:s"),
            "status" => $this->request->getPost('status') ?: 2,
        ];
        if ($validation->run($data)) {

$ServiceModel = new ServiceModel();
            $insert = $ServiceModel->insert($data);
            if ($insert) {
                session()->setFlashdata('message', 'Service added successfully!');
                session()->setFlashdata('message_class', 'success');
                return redirect("admin/services");
            } else {
                session()->setFlashdata('message', 'Something went wrong - Service could not be added!');
                session()->setFlashdata('message_class', 'danger');
                return view("admin/add-service", ['errors' => $validation->getErrors(), 'formData' => $data]);
            }
        } else {
            return view("admin/add-service", ['errors' => $validation->getErrors(), 'formData' => $data]);
        }
    }

public function updateService($serviceId)
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $ServiceModel = new ServiceModel();
        $service = $ServiceModel->find($serviceId);
        return view("admin/update-service", ['service' => $service]);
    }
    public function updateServiceProcess()
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $serviceId = $this->request->getPost('serviceId');
        if (empty($serviceId)) {
            return redirect("admin/services");
        }
        $validation = \Config\Services::validation();
        $validation->setRules([
            'service_name' => 'required',
        ]);

$data = [
            "service_name" => $this->request->getPost('service_name'),
            "update_date" => date("d-m-Y : h:i A"),
            "status" => $this->request->getPost('status') ?: 2,
        ];
        if ($validation->run($data)) {
            $ServiceModel = new ServiceModel();
            $ServiceModel->set($data);
            $ServiceModel->where('id', $serviceId);
            $update = $ServiceModel->update();
            if ($update) {
                session()->setFlashdata('message', 'Service updated successfully!');
                session()->setFlashdata('message_class', 'success');
                return redirect("admin/services");
            } else {
                session()->setFlashdata('message', 'Something went wrong - Service could not be updated!');
                session()->setFlashdata('message_class', 'danger');
                return view("admin/add-service", ['errors' => $validation->getErrors(), 'formData' => $data]);
            }
        } else {
            return view("admin/add-service", ['errors' => $validation->getErrors(), 'formData' => $data]);
        }
    }
    public function deleteService($serviceId)
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        if (empty($serviceId)) {
            return redirect("admin/pages");
        }
        $ServiceModel = new ServiceModel();
        if ($ServiceModel->delete($serviceId)) {
            session()->setFlashdata('message', 'Service deleted successfully!');
            session()->setFlashdata('message_class', 'success');
            return redirect("admin/services");
        } else {
            session()->setFlashdata('message', 'Service could not be deleted!');
            session()->setFlashdata('message_class', 'danger');
            return redirect("admin/services");
        }
    }

public function portfolio()
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $PortfolioModel = new PortfolioModel();

$PortfolioModel->distinct();
        $PortfolioModel->select('dte_service.id, dte_service.service_name');
        $PortfolioModel->join('dte_service', 'dte_service.id = dte_portfolio.service_category', 'left');
        $categories = $PortfolioModel->findAll();

$PortfolioModel->select('dte_portfolio.*, dte_service.service_name');
        $PortfolioModel->join('dte_service', 'dte_service.id = dte_portfolio.service_category', 'left');
        $portfolios = $PortfolioModel->findAll();

return view("admin/portfolio", [
            'categories' => $categories,
            'portfolios' => $portfolios
        ]);
    }

public function add_portfolio()
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $serviceModel = new ServiceModel();
        $serviceModel->where('status', 1);
        $services = $serviceModel->findAll();
        return view("admin/add-portfolio", ['services' => $services]);
    }

public function addPortfolioProcess()
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $serviceModel = new ServiceModel();
        $serviceModel->where('status', 1);
        $services = $serviceModel->findAll();

$validation = \Config\Services::validation();
        $validation->setRules([
            'title' => 'required',
            'service_category' => 'required',
        ]);

$data = [
            "title" => $this->request->getPost('title'),
            "service_category" => $this->request->getPost('service_category'),
            "link" => $this->request->getPost('link'),
            "create_date" => date("d-m-Y : h:i:s"),
            "status" => $this->request->getPost('status') ?: 2,
        ];
        if ($validation->run($data)) {

$file = $this->request->getFile('file');
            $checkFile = $file->getName();
            if (isset($checkFile) && !empty($checkFile)) {
                $uploadPath = 'public/portfolio/';
                $fileName = $file->getRandomName();
                if ($file->isValid() && !$file->hasMoved()) {
                    $file->move($uploadPath, $fileName);
                    // $site_url = base_url('public/blog_uploads/feature_image/');
                    // $data['feature_image'] = $site_url . $fileName;
                    $data['file'] = $fileName;
                }
            } else {
                $data['file'] = "";
            }

$portfolioModel = new PortfolioModel();
            $insert = $portfolioModel->insert($data);
            if ($insert) {
                session()->setFlashdata('message', 'Portfolio added successfully!');
                session()->setFlashdata('message_class', 'success');
                return redirect("admin/portfolio");
            } else {
                session()->setFlashdata('message', 'Something went wrong - Portfolio could not be added!');
                session()->setFlashdata('message_class', 'danger');
                return view("admin/add-portfolio", ['formData' => $data, 'services' => $services]);
            }
        } else {
            return view("admin/add-portfolio", ['errors' => $validation->getErrors(), 'formData' => $data, 'services' => $services]);
        }
    }

public function updatePortfolio($portID)
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $serviceModel = new ServiceModel();
        $serviceModel->where('status', 1);
        $services = $serviceModel->findAll();

$portfolioModel = new PortfolioModel();
        $portfolio = $portfolioModel->find($portID);
        return view("admin/update-portfolio", ['services' => $services, 'portfolio' => $portfolio]);
    }
    public function updatePortfolioProcess($portID)
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $portfolioModel = new PortfolioModel();
        $portfolio = $portfolioModel->find($portID);

if (!$portfolio) {
            session()->setFlashdata('message', 'Portfolio not found!');
            session()->setFlashdata('message_class', 'danger');
            return redirect()->to('/admin/pages');
        }

$serviceModel = new ServiceModel();
        $serviceModel->where('status', 1);
        $services = $serviceModel->findAll();

$validation = \Config\Services::validation();
        $validation->setRules([
            'title' => 'required',
            'service_category' => 'required',
        ]);

$portfolioModel->set($data);
            $portfolioModel->where('id', $portID);
            $update = $portfolioModel->update();
            if ($update) {
                session()->setFlashdata('message', 'Portfolio updated successfully!');
                session()->setFlashdata('message_class', 'success');
                return redirect("admin/portfolio");
            } else {
                session()->setFlashdata('message', 'Something went wrong - Portfolio could not be updated!');
                session()->setFlashdata('message_class', 'danger');
                return view("admin/add-portfolio", ['formData' => $data, 'services' => $services]);
            }
        } else {
            return view("admin/add-portfolio", ['errors' => $validation->getErrors(), 'formData' => $data, 'services' => $services]);
        }
    }

public function deletePortfolio($portId)
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $PortModel = new PortfolioModel();
        if ($PortModel->delete($portId)) {
            session()->setFlashdata('message', 'Portfolio deleted successfully!');
            session()->setFlashdata('message_class', 'success');
            return redirect("admin/portfolio");
        } else {
            session()->setFlashdata('message', 'Portfolio could not be deleted!');
            session()->setFlashdata('message_class', 'danger');
            return redirect("admin/portfolio");
        }
    }

public function team()
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $teamModel = new TeamModel();
        $team = $teamModel->findAll();
        return view("admin/team", ['team' => $team]);
    }
    public function team_detail($teamId)
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $teamModel = new TeamModel();
        $team = $teamModel->find($teamId);
        return view("admin/team-detail", ['team' => $team]);
    }
    public function add_team()
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        return view("admin/add-team");
    }

public function add_team_process()
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $validation = \Config\Services::validation();
        $validation->setRules([
            'name' => 'required',
            'profile' => 'required',
            'description' => 'required',
            'experience' => 'required'
        ]);

$data = [
            "name" => $this->request->getPost('name'),
            "profile" => $this->request->getPost('profile'),
            "description" => $this->request->getPost('description'),
            "experience" => $this->request->getPost('experience'),
            "instagram" => $this->request->getPost('instagram'),
            "facebook" => $this->request->getPost('facebook'),
            "linkedin" => $this->request->getPost('linkedin'),
            "twitter" => $this->request->getPost('twitter'),
            "portfolio" => $this->request->getPost('portfolio'),
            "category" => $this->request->getPost('category'),
            "tags" => $this->request->getPost('tags'),
            "create_date" => date("d-m-Y : h:i:s"),
            "status" => $this->request->getPost('status') ?: 2,
        ];
        if ($validation->run($data)) {

$file = $this->request->getFile('feature_image');
            $checkFile = $file->getName();
            if (isset($checkFile) && !empty($checkFile)) {
                $uploadPath = 'public/team_uploads/';
                $fileName = $file->getRandomName();
                if ($file->isValid() && !$file->hasMoved()) {
                    $file->move($uploadPath, $fileName);
                    // $site_url = base_url('public/blog_uploads/feature_image/');
                    // $data['feature_image'] = $site_url . $fileName;
                    $data['profile_photo'] = $fileName;
                }
            } else {
                $data['profile_photo'] = "";
            }

$teamModel = new TeamModel();
            $insert = $teamModel->insert($data);
            if ($insert) {
                session()->setFlashdata('message', 'Team added successfully!');
                session()->setFlashdata('message_class', 'success');
                return redirect("admin/team");
            } else {
                session()->setFlashdata('message', 'Something went wrong - Team could not be added!');
                session()->setFlashdata('message_class', 'danger');
                return view("admin/add-team", ['formData' => $data]);
            }
        } else {
            return view("admin/add-team", ['errors' => $validation->getErrors(), 'formData' => $data,]);
        }
    }

public function update_team($teamId)
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $teamModel = new TeamModel();
        $teamDetails = $teamModel->find($teamId);
        return view("admin/update-team", ['team' => $teamDetails]);
    }

public function update_team_process($teamId)
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $teamModel = new TeamModel();
        $teamDetails = $teamModel->find($teamId);

if (!$teamDetails) {
            session()->setFlashdata('message', 'Team not found!');
            session()->setFlashdata('message_class', 'danger');
            return redirect()->to('/admin/team');
        }

// Validation rules for blog update
        $validation = \Config\Services::validation();
        $validation->setRules([
            'name' => 'required',
            'profile' => 'required',
            'description' => 'required',
            'experience' => 'required'
        ]);

$data = [
            "name" => $this->request->getPost('name'),
            "profile" => $this->request->getPost('profile'),
            "description" => $this->request->getPost('description'),
            "experience" => $this->request->getPost('experience'),
            "instagram" => $this->request->getPost('instagram'),
            "facebook" => $this->request->getPost('facebook'),
            "linkedin" => $this->request->getPost('linkedin'),
            "twitter" => $this->request->getPost('twitter'),
            "portfolio" => $this->request->getPost('portfolio'),
            "category" => $this->request->getPost('category'),
            "tags" => $this->request->getPost('tags'),
            "update_date" => date("d-m-Y : h:i A"),
            "status" => $this->request->getPost('status') ?: 2,
        ];

if ($validation->run($data)) {
            $file = $this->request->getFile('feature_image');
            if ($file && $file->isValid() && !$file->hasMoved()) {
                $uploadPath = 'public/team_uploads/';
                $fileName = $file->getRandomName();
                $file->move($uploadPath, $fileName);

// Store the new image filename
                $data['profile_photo'] = $fileName;
            } else {
                // If no new file uploaded, keep the current feature image (if any)
                if (empty($data['profile_photo'])) {
                    $data['profile_photo'] = $teamDetails['profile_photo'];
                }
            }

// Update blog in the database
            $teamModel->set($data);
            $teamModel->where('id', $teamId);
            $update = $teamModel->update();

// Check if the update was successful
            if ($update) {
                session()->setFlashdata('message', 'Team updated successfully!');
                session()->setFlashdata('message_class', 'success');
                return redirect("admin/team");
            } else {
                session()->setFlashdata('message', 'Something went wrong - Team could not be updated!');
                session()->setFlashdata('message_class', 'danger');
                return view("admin/update-team", ['errors' => $validation->getErrors(), 'formData' => $data, 'team' => $teamDetails]);
            }
        } else {
            // If validation fails, return to the update form with errors
            return view("admin/update-team", ['errors' => $validation->getErrors(), 'formData' => $data, 'team' => $teamDetails]);
        }
    }

public function redirections()
    {
        $redirectModel = new RedirectionModel();
        $redirectModel->where('status', 1);
        $redirectUrl = $redirectModel->findAll();

return view("admin/redirections", ['redirectUrl' => $redirectUrl]);
    }

public function addRedirections()
    {
        return view("admin/add-redirections");
    }
    public function addRedirectionsProcess()
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $validation = \Config\Services::validation();
        $validation->setRules([
            'from_url' => 'required',
            'to_url' => 'required',
            'status_code' => 'required',
        ]);

$data = [
            "from_url" => $this->request->getPost('from_url'),
            "to_url" => $this->request->getPost('to_url'),
            "status_code" => $this->request->getPost('status_code'),
            "create_date" => date("d-m-Y : h:i A"),
            "status" => $this->request->getPost('status') ?: 2,
        ];
        if ($validation->run($data)) {

$redirectionModel = new RedirectionModel();
            $insert = $redirectionModel->insert($data);
            if ($insert) {
                session()->setFlashdata('message', 'Redirection added successfully!');
                session()->setFlashdata('message_class', 'success');
                return redirect()->to('/admin/redirections');
            } else {
                session()->setFlashdata('message', 'Something went wrong - Redirection could not be added!');
                session()->setFlashdata('message_class', 'danger');
                return view("admin/add-redirections", ['errors' => $validation->getErrors(), 'formData' => $data]);
            }
        } else {
            return view("admin/add-redirections", ['errors' => $validation->getErrors(), 'formData' => $data]);
        }
    }
    public function editRedirections($reId)
    {
        $redirectModel = new RedirectionModel();
        $redirect = $redirectModel->find($reId);
        return view("admin/edit-redirections", ['redirect' => $redirect]);
    }
    public function editRedirectionsProcess()
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }

$redirectId = $this->request->getPost('id');
        if (!$redirectId) {
            return redirect()->to('/admin/redirections');
        }

$validation = \Config\Services::validation();
        $validation->setRules([
            'from_url' => 'required',
            'to_url' => 'required',
            'status_code' => 'required',
        ]);

$data = [
            'id' => $this->request->getPost('id'),
            "from_url" => $this->request->getPost('from_url'),
            "to_url" => $this->request->getPost('to_url'),
            "status_code" => $this->request->getPost('status_code'),
            "update_date" => date("d-m-Y : h:i A"),
            "status" => $this->request->getPost('status') ?: 2,
        ];

if ($validation->run($data)) {
            $redirectionModel = new RedirectionModel();
            // Ensure the redirection exists and update
            if ($redirectionModel->find($redirectId)) {
                $update = $redirectionModel->update($redirectId, $data); // Updating the row by ID

if ($update) {
                    session()->setFlashdata('message', 'Redirection updated successfully!');
                    session()->setFlashdata('message_class', 'success');
                    return redirect()->to('/admin/redirections');
                } else {
                    session()->setFlashdata('message', 'Something went wrong - Redirection could not be updated!');
                    session()->setFlashdata('message_class', 'danger');
                    return view("admin/edit-redirections", ['errors' => $validation->getErrors(), 'formData' => $data]);
                }
            } else {
                session()->setFlashdata('message', 'Redirection not found!');
                session()->setFlashdata('message_class', 'danger');
                return redirect()->to('/admin/redirections');
            }
        } else {
            return view("admin/edit-redirections", ['errors' => $validation->getErrors(), 'formData' => $data]);
        }
    }

public function deleteRedirections($redId)
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $redirectModel = new RedirectionModel();
        if ($redirectModel->delete($redId)) {
            session()->setFlashdata('message', 'Redirection deleted successfully!');
            session()->setFlashdata('message_class', 'success');
            return redirect("admin/redirections");
        } else {
            session()->setFlashdata('message', 'Redirection could not be deleted!');
            session()->setFlashdata('message_class', 'danger');
            return redirect("admin/redirections");
        }
    }

public function sitemap()
    {
        $sitemapModel = new SitemapModel();
        $sitemapUrl = $sitemapModel->findAll();

return view("admin/sitemap", ['sitemapUrl' => $sitemapUrl]);
    }
    public function addSitemap()
    {
        return view("admin/add-sitemap");
    }
    public function addSitemapProcess()
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $validation = \Config\Services::validation();
        $validation->setRules([
            'slug' => 'required',
        ]);
        $slug = $this->request->getPost('slug');
        $data = [
            "slug" => $slug,
            "page_id" => $this->request->getPost('page_id'),
            "blog_id" => $this->request->getPost('blog_id'),
            "create_date" => date("d-m-Y : h:i A"),
            "status" => $this->request->getPost('status') ?: 2,
        ];
        if ($validation->run($data)) {
            $sitemapModel = new SitemapModel();

$count = $sitemapModel->where('slug', $slug)->countAllResults();
            if ($count == 0) {
                $insert = $sitemapModel->insert($data);
                if ($insert) {
                    session()->setFlashdata('message', 'Sitemap added successfully!');
                    session()->setFlashdata('message_class', 'success');
                    return redirect()->to('/admin/sitemap');
                } else {
                    session()->setFlashdata('message', 'Something went wrong - Sitemap could not be added!');
                    session()->setFlashdata('message_class', 'danger');
                    return view("admin/add-sitemap", ['errors' => $validation->getErrors(), 'formData' => $data]);
                }
            } else {
                session()->setFlashdata('message', 'Slug already exist!');
                session()->setFlashdata('message_class', 'danger');
                return view("admin/add-sitemap", ['errors' => $validation->getErrors(), 'formData' => $data]);
            }
        } else {
            return view("admin/add-sitemap", ['errors' => $validation->getErrors(), 'formData' => $data]);
        }
    }

public function updateSitemap($sId)
    {
        $sitemapModel = new SitemapModel();
        $sitemap = $sitemapModel->find($sId);
        return view("admin/update-sitemap", ['sitemap' => $sitemap]);
    }

public function updateSitemapProcess()
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }

$sitemapId = $this->request->getPost('id');
        if (!$sitemapId) {
            return redirect()->to('/admin/sitemap');
        }

$validation = \Config\Services::validation();
        $validation->setRules([
            'slug' => 'required',
        ]);
        $slug = $this->request->getPost('slug');
        $data = [
            "slug" => $slug,
            "page_id" => $this->request->getPost('page_id'),
            "blog_id" => $this->request->getPost('blog_id'),
            "create_date" => date("d-m-Y : h:i A"),
            "status" => $this->request->getPost('status') ?: 2,
        ];

if ($validation->run($data)) {
            $sitemapModel = new SitemapModel();

$count = $sitemapModel->where(['slug' => $slug, 'id !=' => $sitemapId])->countAllResults();
            if ($count == 0) {

if ($sitemapModel->find($sitemapId)) {
                    $update = $sitemapModel->update($sitemapId, $data);

if ($update) {
                        session()->setFlashdata('message', 'Sitemap updated successfully!');
                        session()->setFlashdata('message_class', 'success');
                        return redirect()->to('/admin/sitemap');
                    } else {
                        session()->setFlashdata('message', 'Something went wrong - Sitemap could not be updated!');
                        session()->setFlashdata('message_class', 'danger');
                        return view("admin/update-sitemap", ['errors' => $validation->getErrors(), 'formData' => $data]);
                    }
                } else {
                    session()->setFlashdata('message', 'Sitemap not found!');
                    session()->setFlashdata('message_class', 'danger');
                    return redirect()->to('/admin/sitemap');
                }
            } else {
                session()->setFlashdata('message', 'slug already exist!');
                session()->setFlashdata('message_class', 'danger');
                return view("admin/update-sitemap", ['errors' => $validation->getErrors(), 'formData' => $data]);
            }
        } else {
            return view("admin/update-sitemap", ['errors' => $validation->getErrors(), 'formData' => $data]);
        }
    }

public function deleteSitemap($sId)
    {
        if (!session()->has('admin_email')) {
            return redirect("admin/login");
        }
        $sitemapModel = new SitemapModel();
        if ($sitemapModel->delete($sId)) {
            session()->setFlashdata('message', 'Sitemap deleted successfully!');
            session()->setFlashdata('message_class', 'success');
            return redirect("admin/sitemap");
        } else {
            session()->setFlashdata('message', 'Sitemap could not be deleted!');
            session()->setFlashdata('message_class', 'danger');
            return redirect("admin/sitemap");
        }
    }
}

cmd: