PHP - Php: Displaying Different Menus To Different User Types.

can someone explain to me why PHP returns so many different variants when throwing out visitor info using this piece of code?

$ip = gethostbyaddr($_SERVER['REMOTE_ADDR']);

here are some examples I have seen recently:

planetlab24.gino-research.net.in.tum.de
10.32.64.124
49.129.197.35.bc.googleusercontent.com
abts-north-dynamic-142.110.68.182.airtelbroadband.in
173-20-152-84.client.mchsi.com

now, obviously i can understand the google one, and a few others. but, given the info and insight on these pages: https://www.php.net/manual/en/function.gethostbyaddr.php , and https://www.php.net/reserved.variables.server , why are the returns so different for different people? why does PHP see all different kinds of things? is the cause the way the user’s server is configured? some identifying info OF the server? and what about reserved IPs? like the “10.xx…” one I listed above? I’ve seen hundreds from that pool, and other blocks of reserved ones, and they have never had alpha-chars included in their captures. it’s always only the IP numbers. there a reason for that? really, all I’m looking for is why I see what I see. anyone help? furthermore, does anyone know if other server-side languages like c#, python, ruby or any js frameworks return different results than PHP ever would? thanks.

I've asked this question before but still haven't really figured out how best to implement it, and have found myself hitting another roadblock.

I have multiple types of charts (i.e. bar, pie, etc), and various endpoints to access them.  I like to keep my routing script uncluttered, and feel the following does so.

$app->get('/chart', function (Request $request, Response $response) {
    //List of chart with optional filtering
    $this->chartService->index($request->getQueryParams());
    return $this->chartResponder->index($response, $index);
});

$app->post('/chart', function (Request $request, Response $response) {
    //Create a new chart of type (i.e. bar, pie, etc) specified by type parameter
    $chart=$this->chartService->create($request->getParsedBody());
    return $this->chartResponder->create($response, $chart);
});

$app->get('/chart/{id:[0-9]+}', function (Request $request, Response $response, $args) {
    //View chart of given ID
    $chart=$this->chartService->detail((int)$args['id']);
    return $this->chartResponder->delete($response, $chart);
});

$app->delete('/chart/{id:[0-9]+}', function (Request $request, Response $response, $args) {
    //Delete chart of given ID
    $this->chartService->delete((int)$args['id']);
    return $this->chartResponder->delete($response, null);
});

$app->post('/chart/{id:[0-9]+}/series', function (Request $request, Response $response, $args) {
    //Add a new series to the collection for chart with given ID
    $chart=$this->chartService->addSeries((int)$args['id'], $request->getParsedBody());
    return $this->chartResponder->update($response, $chart);
});

$app->put('/chart/{id:[0-9]+}/series/{seriesPosition:[0-9]+}', function (Request $request, Response $response, $args) {
    //Modify series of given position in the collection for chart with given ID
    $chart=$this->chartService->updateSeries((int)$args['id'], (int)$args['seriesPosition'], $request->getParsedBody());
    return $this->chartResponder->update($response, $chart);
});

//More endpoints for chart of given ID...

I then created the following service to support the endpoints.  Off topic, but is this a service or a controller?

My index() method is chart type agnostic.  My create() method needs a means to determine what type of chart to create, and does so using the received chart "type" passed in the body to get the applicable repository.  All the other methods receive the chart ID in the URL path and use it to first get the chart entity and then get the applicable repository based on the object.  All seems good!

<?php
namespace NotionCommotion\ChartBuilder\Service;
use NotionCommotion\ChartBuilder\Entity\Chart;

class ChartService
{
    protected $em;
    
    public function __construct(\Doctrine\ORM\EntityManager $em)
    {
        $this->em = $em;
    }

    public function index(array $params=[]):array {
        return $this->em->getRepository(Chart::class)->index($params);
    }

    public function create(array $params):Chart {
        //Get the specific repo based on $params['type].  Not perfect, but good enough
        $discriminatorMap=$this->em->getClassMetadata(Chart::class)->discriminatorMap;
        $repo = $this->em->getRepository($discriminatorMap[$params['type']]);
        //Validate data
        $chart=$repo->create($params);
        $this->em->persist($chart);
        $this->em->flush();
        return $chart;
    }

    public function read(int $id):Chart {
        return $this->em->getRepository(Chart::class)->find($id);
    }

    public function delete(int $id):void {
        $this->em->remove($this->read($id));
        $this->em->flush();
    }

    public function addSeries(int $idPublic, array $id):Chart {
        $chart=$this->read($id);
        //Validate data
        $repo=$this->em->getRepository(get_class($chart));
        $repo->addSeries($chart, $params);
        $this->em->persist($chart);
        $this->em->flush();
        return $chart;
    }

    public function updateSeries(int $id, int $position, array $params):Chart {
        $chart=$this->read($id);
        $series=$chart->getSeries();
        $seriesNode=$series->offsetGet($position);
        //Validate data
        $repo=$this->em->getRepository(get_class($seriesNode));
        $repo->update($seriesNode, $params);
        $this->em->persist($chart);
        $this->em->flush();
        return $chart;
    }
}

Until...  I find myself needing to put non-database related functionality in the repository and violating the single responsibility principle.  I am not a complete purist and might be willing to do so, however, there does not appear to be a clean way to inject dependencies in a Doctrine repository.

One thought I had was to create specialized services maybe as follows:

$c['chartService'] = function ($c) {
    return new ChartService(
        $c[EntityManager::class],
        [
            'bar'=>function ($c) {return new BarChartService($c[EntityManager::class]);},
            'pie'=>function ($c) {return new PieChartService($c[EntityManager::class], $c['someOtherObject']);},
            //add more types...
        ]
    );
};

class ChartService
{
    protected $em, $subServices=[];
    
    public function __construct(\Doctrine\ORM\EntityManager $em, $subServices)
    {
        $this->em = $em;
        $this->subServices = $subServices;
    }

    public function index(array $params=[]):array {/* no change */}

    public function create(array $params):Chart {/* maybe no change */}

    public function __call($name, $args) {
        $chart=$this->em->getRepository(Chart::class)->find($args[0]);
        $subservice=$this->getSubservice($chart);
        $args[0]=$chart;
        return $subservice->$name(...$args);
    }
}

abstract class AbstractSpecificChartService
{
    protected $em;
    
    public function __construct(\Doctrine\ORM\EntityManager $em)
    {
        $this->em = $em;
    }

    public function __call($name, $args) {
        throw new \Exception("Method $name not supported");
    }

    protected function getSubservice(Chart $chart):self {
        //Haven't figured out but can do so if needed.
    }

    public function delete(Chart $chart):void {
        //Include methods common to all charts here
        $this->em->remove($chart);
        $this->em->flush();
    }

    protected function helperMethods($foo) {
        //If necessary.
    }
}

class BarChartService extends AbstractSpecificChartService
{
    //Override __construct if necessary

    public function updateSeries(Chart $chart, int $position, array $params):Chart {
        //Note that Chart and not $id is passed.
        //implement code as needed
        return $chart;
    }
}

While this will provide some flexibility, I've been stung more than once using inheritance when injection should be used, and am worried it will lead to no good.  But what would I inject?  I previously suggested injecting a BarChart into a Chart and received a response that doing so is nonsensible.

So, after this long story, how should I implement this?  Thank you

<?php

$title = isset($_POST['title']) ? $_POST['title'] : null;
$desc = nl2br(isset($_POST['description'])) ? $_POST['description'] : null;
$name = isset($_POST['fullname']) ? $_POST['fullname'] : null;
$email = isset($_POST['email']) ? $_POST['email'] : null;
$country = isset($_POST['country']) ? $_POST['country'] : null;

$video = isset($_FILES['video']);
$videoname = isset($_FILES['video']['name']);
$videotmp = isset($_FILES['video']['tmp_name']);
$videosize = isset($_FILES['video']['size']);
$videotype = isset($_FILES['video']['type']);
$videoacceptable = array(
        "video/mp4",
        "video/ogg",
        "video/quicktime",
);

$videopath = "/videos/";
$videofile = $videopath . $video;

if(isset($_POST['submit'])) {

//ERROR MESSAGES / VALIDATION

if(empty($title)) {
    $errors[] = "A title is required"; 
    echo "<style type=\"text/css\"> #title { background-color:#F5A9A9;border:1px solid #DF0101; } </style>";
} elseif(strlen($title) > 80) {
    $errors[] = "Your title can only be 80 characters long"; 
    echo "<style type=\"text/css\"> #title { background-color:#F5A9A9;border:1px solid #DF0101; } </style>";
}
if(empty($desc)) {
    $errors[] = "A description is required";
    echo "<style type=\"text/css\"> #description { background-color:#F5A9A9;border:1px solid #DF0101; } </style>";
}
if(empty($name)) {
    $errors[] = "Please enter your full name";
    echo "<style type=\"text/css\"> #fullname { background-color:#F5A9A9;border:1px solid #DF0101; } </style>";
} elseif(strlen($name) > 32) {
    $errors[] = "Your name can only be 32 characters long";
    echo "<style type=\"text/css\"> #fullname { background-color:#F5A9A9;border:1px solid #DF0101; } </style>";
}
if(empty($email)) {
    $errors[] = "Please enter your email address";
    echo "<style type=\"text/css\"> #email { background-color:#F5A9A9;border:1px solid #DF0101; } </style>";
} elseif(strlen($email) > 50) {
    $errors[] = "Your email addess can only be 50 characters long";
    echo "<style type=\"text/css\"> #email { background-color:#F5A9A9;border:1px solid #DF0101; } </style>";
} elseif (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
    $errors[] = "Please enter a valid email address";
    echo "<style type=\"text/css\"> #email { background-color:#F5A9A9;border:1px solid #DF0101; } </style>";
}
if($videosize = 0) {
    $errors[] = "You forgot to upload a video";
} elseif($videosize >= 20000000) {
    $errors[] = "Your video size is too large, 20mb max";
} elseif(!in_array($videotype, $videoacceptable)) {
    $errors[] = "The file type is not allowed, only allowed .mp4, .ogg and .mov";
}

if(count($errors) === 0) {
    $connect = mysqli_connect("localhost","username","password");
        if(!$connect) {
            header("Location:"); // ADD ERROR LINK
        }
    $dbselect = mysqli_select_db("database");
        if(!$dbselect) {
            header("Location:"); // ADD ERROR LINK
        }

    $query = mysqli_query("INSERT INTO cover_videos(title, desc, name, email, country, videotmp, videotype, videosize, videopath) VALUES('$title','$desc','$name','$email','$country','$videotmp','$videotype','$videosize','$videopath')");
    move_uploaded_file($videotmp, $videofile);

    //SEND AN EMAIL TO THE USER     
    $to = $email;
    $subject = "Thank's for your upload";

    $message = '
        <html>
            <head><title>We have received your video</title></head>
            <body>
                <h3>Good News!</h3>
                <p>We have recieved your video and is awaiting approval.</p>
            </body>
        </html>
    ';

    $headers = 'FROM: no-replyk' . "\r\n";
    $headers = 'MIME-Version: 1.0' . "\r\n";
    $headers = 'Content-type: text/html; charset=iso-8859-1' . "\r\n";
    $headers = 'X-Mailer: PHP/' . phpversion();

    mail($to, $subject, $message, $headers);

    header("Location:"); //SUCCESSFUL UPLOAD PAGE

    }

}

?>

    //DO NOT TRUST $_FILES['upfile']['mime'] VALUE !!
    //Check MIME Type by yourself.
     $finfo = new finfo(FILEINFO_MIME_TYPE);
     if (false === $ext = array_search(
         $finfo->file($_FILES['resume_path']['tmp_name']),
         array(
            'txt' => 'text/plain',
            'doc' => 'application/msword',
            'pdf' => 'application/pdf',
         ),
         true
     )) {
         throw new RuntimeException('Invalid file format.');
     }
     echo "Sorry, invalid file format.  Please try again.";
     echo $ext;