resq/src/Controller/ResqAPI/PartnerController.php

<?php

namespace App\Controller\ResqAPI;

use Symfony\Bundle\FrameworkBundle\Controller\Controller;
use Symfony\Component\HttpFoundation\Request;

use Doctrine\ORM\Query;
use Doctrine\ORM\EntityManagerInterface;

use Catalyst\APIBundle\Controller\APIController;
// TODO: what do we use for response? APIResponse or APIResult?
// APIResult is what is used by APIController. APIResponse is what is used by CAPI
use Catalyst\APIBundle\Response\APIResponse;
use App\Ramcar\APIResult;

use App\Entity\Partner;
use App\Entity\Review;

use Catalyst\APIBundle\Access\Generator as ACLGenerator;

class PartnerController extends APIController
{
    protected $acl_gen;

    public function __construct(ACLGenerator $acl_gen)
    {
        $this->acl_gen = $acl_gen;
    }

    public function getClosestPartners(Request $req, EntityManagerInterface $em)
    {
        $required_params = [
            'longitude',
            'latitude',
            'service_id',
            'limit',
        ];
        $res = $this->checkParamsAndKey($req, $em, $required_params);
        if ($res->isError())
            return $res->getReturnResponse();

        $long = $req->query->get('longitude');
        $lat = $req->query->get('latitude');
        $service_id = $req->query->get('service_id');
        $limit = $req->query->get('limit');

        // get partners within range
        $query = $em->createQuery('SELECT p, st_distance(p.coordinates, point(:lng, :lat)) as dist FROM App\Entity\Partner p
                JOIN App\Entity\Service s where s.id = :service_id ORDER BY dist')
                ->setParameter('lat', $lat)
                ->setParameter('lng', $long)
                ->setParameter('service_id', $service_id);

        $query->setMaxResults($limit);
        $result = $query->getResult();

        $data = [];
        $partners = [];
        foreach($result as $row)
        {
            $partners[] =  [
                'id' => $row[0]->getID(),
                'name' => $row[0]->getName(),
                'branch' => $row[0]->getBranch(),
                'address' => $row[0]->getAddress(),
                'contact_nums' => $row[0]->getContactNumbers(),
                'time_open' => $row[0]->getTimeOpen()->format("g:i A"),
                'time_close' => $row[0]->getTimeClose()->format("g:i A"),
                'longitude' => $row[0]->getCoordinates()->getLongitude(),
                'latitude' => $row[0]->getCoordinates()->getLatitude(),
                'db_distance' => $row['dist'],
            ];
        }

        $data['partners'] = $partners;

        $res->setData($data);

        return $res->getReturnResponse();
    }

    public function getPartnerInformation(Request $req, $pid, EntityManagerInterface $em)
    {
        $required_params = [];
        $res = $this->checkParamsAndKey($req, $em, $required_params);
        if ($res->isError())
            return $res->getReturnResponse();

        // get partner
        $partner = $em->getRepository(Partner::class)->findOneBy(['id' => $pid]);
        if ($partner == null)
        {
            $res->setError(true)
                ->setErrorMessage('No partner found.');
            return $res->getReturnResponse();
        }

        // get reviews for partner
        $reviews = $em->getRepository(Review::class)->findBy(['partner' => $partner]);

        // get average rating for all reviews
        $average_rating = 0;
        if (!empty($reviews))
        {
            $rating = 0;
            foreach($reviews as $review)
            {
                $rating = $rating + $review->getRating();
            }

            $average_rating = $rating / sizeof($reviews);
        }

        $data['partner'] = [
            'id' => $partner->getID(),
            'name' => $partner->getName(),
            'branch' => $partner->getBranch(),
            'address' => $partner->getAddress(),
            'contact_nums' => $partner->getContactNumbers(),
            'time_open' => $partner->getTimeOpen()->format("g:i A"),
            'time_close' => $partner->getTimeClose()->format("g:i A"),
            'longitude' => $partner->getCoordinates()->getLongitude(),
            'latitude' => $partner->getCoordinates()->getLatitude(),
            'average_rating' => $average_rating,
        ];

        $res->setData($data);

        return $res->getReturnResponse();
    }

    public function reviewPartner($pid, Request $req, EntityManagerInterface $em)
    {
        $required_params = [
            'rating',
            'message',
        ];

        $res = $this->checkParamsAndKey($req, $em, $required_params);
        if ($res->isError())
            return $res->getReturnResponse();

        $rating = $req->request->get('rating');
        $msg = $req->request->get('message');

        // TODO: check rating if 1 - 5

        // check if partner exists
        $partner = $em->getRepository(Partner::class)->find($pid);
        if ($partner == null)
        {
            $res->setError(true)
                ->setErrorMessage('No partner found.');
            return $res->getReturnResponse();
        }

        $rev = new Review();
        $rev->setRating($rating)
            ->setMessage($msg)
            ->setPartner($partner)
            ->setMobileSession($this->session);

        // save to db
        $em->persist($rev);
        $em->flush();

        $data = [];
        $res->setData($data);

        return $res->getReturnResponse();
    }

    // TODO: since we broke the functions into separate files, we need
    // to figure out how to make this accessible to all ResqAPI controllers
    protected function checkParamsAndKey(Request $req, $em, $params)
    {
        // TODO: depends on what we decide to return
        // returns APIResult object
        $res = new APIResult();

        // check for api_key in query string
        $api_key = $req->query->get('api_key');
        if (empty($api_key))
        {
            $res->setError(true)
                ->setErrorMessage('Missing API key');
            return $res;
        }

        // check missing parameters
        $missing = $this->checkMissingParameters($req, $params);
        if (count($missing) > 0)
        {
            $miss_string = implode(', ', $missing);
            $res->setError(true)
                ->setErrorMessage('Missing parameter(s): ' . $miss_string);
            return $res;
        }

        // check api key
        $mobile_user = $this->checkAPIKey($em, $req->query->get('api_key'));
        if ($mobile_user == null)
        {
            $res->setError(true)
                ->setErrorMessage('Invalid API Key');
            return $res;
        }

        // store session
        $this->session = $sess;

        return $res;
    }

    // TODO: this might not be needed if we use APIController's checkRequiredParameters
    // or we put this into a service?
    protected function checkMissingParameters(Request $req, $params = [])
    {
        $missing = [];

        // check if parameters are there
        foreach ($params as $param)
        {
            if ($req->getMethod() == 'GET')
            {
                $check = $req->query->get($param);
                if (empty($check))
                    $missing[] = $param;
            }
            else if ($req->getMethod() == 'POST')
            {
                $check = $req->request->get($param);
                if (empty($check))
                    $missing[] = $param;
            }
            else
                return $params;
        }

        return $missing;
    }

    // TODO: type hint entity manager
    // TODO: since we broke the functions into separate files, we need
    // to figure out how to make this accessible to all ResqAPI controllers
    protected function checkAPIKey($em, $api_key)
    {
        // find the api key (session id)
        // TODO: user validation needs to be changed
        $m_user = $em->getRepository(MobileUser::class)->find($api_key);
        if ($m_user == null)
            return null;

        return $m_user;
    }
}