685 lines
20 KiB
PHP
685 lines
20 KiB
PHP
<?php
|
|
|
|
namespace App\Controller;
|
|
|
|
use Doctrine\ORM\Query;
|
|
use Doctrine\ORM\QueryBuilder;
|
|
use Doctrine\DBAL\DBALException;
|
|
use Symfony\Component\HttpFoundation\Request;
|
|
use Symfony\Component\HttpFoundation\Response;
|
|
use Symfony\Bundle\FrameworkBundle\Controller\Controller;
|
|
use Symfony\Component\HttpFoundation\JsonResponse;
|
|
|
|
use App\Ramcar\APIResult;
|
|
|
|
use App\Entity\MobileSession;
|
|
use App\Entity\Customer;
|
|
use App\Entity\VehicleManufacturer;
|
|
use App\Entity\Vehicle;
|
|
use App\Entity\CustomerVehicle;
|
|
|
|
use DateTime;
|
|
|
|
|
|
class APIController extends Controller
|
|
{
|
|
protected $session;
|
|
|
|
public function __construct()
|
|
{
|
|
$this->session = null;
|
|
}
|
|
|
|
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
|
|
protected function checkAPIKey($em, $api_key)
|
|
{
|
|
// find the api key (session id)
|
|
$session = $em->getRepository(MobileSession::class)->find($api_key);
|
|
if ($session == null)
|
|
return null;
|
|
|
|
return $session;
|
|
}
|
|
|
|
protected function checkParamsAndKey(Request $req, $em, $params)
|
|
{
|
|
// 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
|
|
$sess = $this->checkAPIKey($em, $req->query->get('api_key'));
|
|
if ($sess == null)
|
|
{
|
|
$res->setError(true)
|
|
->setErrorMessage('Invalid API Key');
|
|
return $res;
|
|
}
|
|
|
|
// store session
|
|
$this->session = $sess;
|
|
|
|
return $res;
|
|
}
|
|
|
|
public function register(Request $req)
|
|
{
|
|
$res = new APIResult();
|
|
|
|
// confirm parameters
|
|
$required_params = [
|
|
'phone_model',
|
|
'os_type',
|
|
'os_version',
|
|
'device_push_id'
|
|
];
|
|
|
|
$missing = $this->checkMissingParameters($req, $required_params);
|
|
if (count($missing) > 0)
|
|
{
|
|
$params = implode(', ', $missing);
|
|
$res->setError(true)
|
|
->setErrorMessage('Missing parameter(s): ' . $params);
|
|
return $res->getReturnResponse();
|
|
}
|
|
|
|
$em = $this->getDoctrine()->getManager();
|
|
|
|
// retry until we get a unique id
|
|
while (true)
|
|
{
|
|
try
|
|
{
|
|
// instantiate session
|
|
$sess = new MobileSession();
|
|
$sess->setPhoneModel($req->request->get('phone_model'))
|
|
->setOSType($req->request->get('os_type'))
|
|
->setOSVersion($req->request->get('os_version'))
|
|
->setDevicePushID($req->request->get('device_push_id'));
|
|
|
|
// reopen in case we get an exception
|
|
if (!$em->isOpen())
|
|
{
|
|
$em = $em->create(
|
|
$em->getConnection(),
|
|
$em->getConfiguration()
|
|
);
|
|
}
|
|
|
|
// save
|
|
$em->persist($sess);
|
|
$em->flush();
|
|
}
|
|
catch (DBALException $e)
|
|
{
|
|
error_log($e->getMessage());
|
|
// delay one second and try again
|
|
sleep(1);
|
|
continue;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
// return data
|
|
$data = [
|
|
'session_id' => $sess->getID()
|
|
];
|
|
$res->setData($data);
|
|
|
|
|
|
// response
|
|
return $res->getReturnResponse();
|
|
}
|
|
|
|
public function confirmNumber(Request $req)
|
|
{
|
|
// check parameters
|
|
$required_params = [
|
|
'phone_number',
|
|
];
|
|
|
|
// check required parameters and api key
|
|
$em = $this->getDoctrine()->getManager();
|
|
$res = $this->checkParamsAndKey($req, $em, $required_params);
|
|
if ($res->isError())
|
|
return $res->getReturnResponse();
|
|
|
|
// phone number
|
|
$phone_number = $req->request->get('phone_number');
|
|
|
|
// TODO: spam protection
|
|
|
|
// TODO: validate phone number
|
|
|
|
// TODO: generate code and save
|
|
// use '123456' for now
|
|
$code = '123456';
|
|
$this->session->setConfirmCode($code)
|
|
->setPhoneNumber($phone_number);
|
|
$em->flush();
|
|
|
|
// TODO: send sms to number
|
|
|
|
// response
|
|
return $res->getReturnResponse();
|
|
}
|
|
|
|
public function validateCode(Request $req)
|
|
{
|
|
// check parameters
|
|
$required_params = [
|
|
'code',
|
|
];
|
|
|
|
// check required parameters and api key
|
|
$em = $this->getDoctrine()->getManager();
|
|
$res = $this->checkParamsAndKey($req, $em, $required_params);
|
|
if ($res->isError())
|
|
return $res->getReturnResponse();
|
|
|
|
// code is wrong
|
|
$code = $req->request->get('code');
|
|
if ($this->session->getConfirmCode() != $code)
|
|
{
|
|
$res->setError(true)
|
|
->setErrorMessage('Wrong confirm code');
|
|
return $res->getReturnResponse();
|
|
}
|
|
|
|
// set confirm date
|
|
$date = new DateTime();
|
|
$this->session->setDateConfirmed($date)
|
|
->setConfirmed();
|
|
$em->flush();
|
|
|
|
// response
|
|
return $res->getReturnResponse();
|
|
}
|
|
|
|
public function getInfo(Request $req)
|
|
{
|
|
// check required parameters and api key
|
|
$required_params = [];
|
|
$em = $this->getDoctrine()->getManager();
|
|
$res = $this->checkParamsAndKey($req, $em, $required_params);
|
|
if ($res->isError())
|
|
return $res->getReturnResponse();
|
|
|
|
// if no customer found
|
|
$cust = $this->session->getCustomer();
|
|
if ($cust == null)
|
|
{
|
|
$data = [
|
|
'first_name' => '',
|
|
'last_name' => '',
|
|
];
|
|
$res->setData($data);
|
|
|
|
return $res->getReturnResponse();
|
|
}
|
|
|
|
// send back customer details
|
|
$data = [
|
|
'first_name' => $cust->getFirstName(),
|
|
'last_name' => $cust->getLastName(),
|
|
];
|
|
$res->setData($data);
|
|
|
|
return $res->getReturnResponse();
|
|
}
|
|
|
|
public function updateInfo(Request $req)
|
|
{
|
|
// check required parameters and api key
|
|
$required_params = [
|
|
'first_name',
|
|
'last_name',
|
|
];
|
|
$em = $this->getDoctrine()->getManager();
|
|
$res = $this->checkParamsAndKey($req, $em, $required_params);
|
|
if ($res->isError())
|
|
return $res->getReturnResponse();
|
|
|
|
// create new customer if it's not there
|
|
$cust = $this->session->getCustomer();
|
|
if ($cust == null)
|
|
{
|
|
$cust = new Customer();
|
|
$em->persist($cust);
|
|
|
|
$this->session->setCustomer($cust);
|
|
}
|
|
|
|
$cust->setFirstName($req->request->get('first_name'))
|
|
->setLastName($req->request->get('last_name'))
|
|
->setConfirmed($this->session->isConfirmed());
|
|
|
|
$em->flush();
|
|
|
|
return $res->getReturnResponse();
|
|
}
|
|
|
|
public function getStatus(Request $req)
|
|
{
|
|
// check required parameters and api key
|
|
$required_params = [];
|
|
$em = $this->getDoctrine()->getManager();
|
|
$res = $this->checkParamsAndKey($req, $em, $required_params);
|
|
if ($res->isError())
|
|
return $res->getReturnResponse();
|
|
|
|
// set data
|
|
$data = [];
|
|
if ($this->session->isConfirmed())
|
|
$data['status'] = 'confirmed';
|
|
else
|
|
$data['status'] = 'unconfirmed';
|
|
$res->setData($data);
|
|
|
|
return $res->getReturnResponse();
|
|
}
|
|
|
|
public function listVehicleManufacturers(Request $req)
|
|
{
|
|
// check required parameters and api key
|
|
$required_params = [];
|
|
$em = $this->getDoctrine()->getManager();
|
|
$res = $this->checkParamsAndKey($req, $em, $required_params);
|
|
if ($res->isError())
|
|
return $res->getReturnResponse();
|
|
|
|
// get manufacturer list
|
|
$mfgs = $em->getRepository(VehicleManufacturer::class)->findBy([], ['name' => 'asc']);
|
|
$mfg_list = [];
|
|
foreach ($mfgs as $mfg)
|
|
{
|
|
$mfg_list[] = [
|
|
'id' => $mfg->getID(),
|
|
'name' => $mfg->getName(),
|
|
];
|
|
}
|
|
|
|
$data = [
|
|
'manufacturers' => $mfg_list
|
|
];
|
|
$res->setData($data);
|
|
|
|
return $res->getReturnResponse();
|
|
}
|
|
|
|
public function listVehicleMakes(Request $req, $mfg_id)
|
|
{
|
|
// check required parameters and api key
|
|
$required_params = [];
|
|
$em = $this->getDoctrine()->getManager();
|
|
$res = $this->checkParamsAndKey($req, $em, $required_params);
|
|
if ($res->isError())
|
|
return $res->getReturnResponse();
|
|
|
|
// get manufacturer
|
|
$mfg = $em->getRepository(VehicleManufacturer::class)->find($mfg_id);
|
|
if ($mfg == null)
|
|
{
|
|
$res->setError(true)
|
|
->setErrorMessage('Invalid vehicle manufacturer id');
|
|
return $res->getReturnResponse();
|
|
}
|
|
|
|
// get makes
|
|
$vehicles = $mfg->getVehicles();
|
|
$vlist = [];
|
|
foreach ($vehicles as $v)
|
|
{
|
|
$vlist[] = [
|
|
'id' => $v->getID(),
|
|
'make' => $v->getMake() . ' ' . $v->getModelYearFrom() . '-' . $v->getModelYearTo(),
|
|
];
|
|
}
|
|
|
|
$data = [
|
|
'manufacturer' => [
|
|
'id' => $mfg->getID(),
|
|
'name' => $mfg->getName(),
|
|
],
|
|
'makes' => $vlist,
|
|
];
|
|
|
|
$res->setData($data);
|
|
|
|
return $res->getReturnResponse();
|
|
}
|
|
|
|
protected function checkVehicleRequirements(Request $req)
|
|
{
|
|
// check required parameters and api key
|
|
$required_params = [
|
|
'make_id',
|
|
'name',
|
|
'plate_num',
|
|
'model_year',
|
|
'color',
|
|
'condition',
|
|
'fuel_type',
|
|
];
|
|
$em = $this->getDoctrine()->getManager();
|
|
$res = $this->checkParamsAndKey($req, $em, $required_params);
|
|
if ($res->isError())
|
|
return $res;
|
|
|
|
// TODO: check valid plate number
|
|
// TODO: check valid fuel type (gas / diesel)
|
|
// TODO: check current battery id
|
|
// TODO: check condition (brand new / second-hand)
|
|
// TODO: check is_motolite and is_active (1 or 0)
|
|
// TODO: check warranty expiration date (YYYYMMDD)
|
|
// TODO: check model year coverage if it fits in between
|
|
|
|
return $res;
|
|
}
|
|
|
|
protected function setCustomerVehicleObject(Request $req, APIResult $res, CustomerVehicle $cv)
|
|
{
|
|
$em = $this->getDoctrine()->getManager();
|
|
|
|
// check customer
|
|
$cust = $this->session->getCustomer();
|
|
if ($cust == null)
|
|
{
|
|
$res->setError(true)
|
|
->setErrorMessage('No customer information found');
|
|
return $res;
|
|
}
|
|
|
|
// get vehicle
|
|
$vehicle = $em->getRepository(Vehicle::class)->find($req->request->get('make_id'));
|
|
if ($vehicle == null)
|
|
{
|
|
$res->setError(true)
|
|
->setErrorMessage('Invalid vehicle make id');
|
|
return $res;
|
|
}
|
|
|
|
$cv->setCustomer($cust)
|
|
->setVehicle($vehicle)
|
|
->setName($req->request->get('name'))
|
|
->setPlateNumber($req->request->get('plate_num'))
|
|
->setModelYear($req->request->get('model_year'))
|
|
->setColor($req->request->get('color'))
|
|
->setFuelType($req->request->get('fuel_type'))
|
|
->setStatusCondition($req->request->get('condition'));
|
|
|
|
// set warranty code and expiration
|
|
// TODO: check warranty requirements
|
|
if (!empty($req->request->get('wty_code')))
|
|
$cv->setWarrantyCode($req->request->get('wty_code'));
|
|
if (!empty($req->request->get('wty_expire')))
|
|
$cv->setWarrantyExpiration(new DateTime($req->request->get('wty_expire')));
|
|
|
|
// TODO: get current battery
|
|
|
|
// is motolite
|
|
if ($req->request->get('is_motolite') == 0)
|
|
$cv->setHasMotoliteBattery(false);
|
|
else
|
|
$cv->setHasMotoliteBattery(true);
|
|
|
|
// is active
|
|
if ($req->request->get('is_active') == 0)
|
|
$cv->setActive(false);
|
|
else
|
|
$cv->setActive(true);
|
|
|
|
// save
|
|
$em->persist($cv);
|
|
$em->flush();
|
|
|
|
// data
|
|
$data = [
|
|
'cv_id' => $cv->getID()
|
|
];
|
|
$res->setData($data);
|
|
|
|
return $res;
|
|
}
|
|
|
|
public function addVehicle(Request $req)
|
|
{
|
|
// check requirements
|
|
$res = $this->checkVehicleRequirements($req);
|
|
if ($res->isError())
|
|
return $res->getReturnResponse();
|
|
|
|
// customer vehicle
|
|
$cv = new CustomerVehicle();
|
|
|
|
$res = $this->setCustomerVehicleObject($req, $res, $cv);
|
|
|
|
return $res->getReturnResponse();
|
|
}
|
|
|
|
public function updateVehicle(Request $req, $id)
|
|
{
|
|
// check requirements
|
|
$res = $this->checkVehicleRequirements($req);
|
|
if ($res->isError())
|
|
return $res->getReturnResponse();
|
|
|
|
// get customer vehicle
|
|
$em = $this->getDoctrine()->getManager();
|
|
$cv = $em->getRepository(CustomerVehicle::class)->find($id);
|
|
|
|
// check if it exists
|
|
if ($cv == null)
|
|
{
|
|
$res->setError(true)
|
|
->setErrorMessage('Vehicle does not exist');
|
|
return $res->getReturnResponse();
|
|
}
|
|
|
|
// check if it's owned by customer
|
|
if ($cv->getCustomer()->getID() != $this->session->getCustomer()->getID())
|
|
{
|
|
$res->setError(true)
|
|
->setErrorMessage('Invalid vehicle');
|
|
return $res->getReturnResponse();
|
|
}
|
|
|
|
$res = $this->setCustomerVehicleObject($req, $res, $cv);
|
|
|
|
return $res->getReturnResponse();
|
|
}
|
|
|
|
public function listVehicles(Request $req)
|
|
{
|
|
// check required parameters and api key
|
|
$required_params = [];
|
|
$em = $this->getDoctrine()->getManager();
|
|
$res = $this->checkParamsAndKey($req, $em, $required_params);
|
|
if ($res->isError())
|
|
return $res->getReturnResponse();
|
|
|
|
// customer
|
|
$cust = $this->session->getCustomer();
|
|
if ($cust == null)
|
|
{
|
|
$res->setError(true)
|
|
->setErrorMessage('No customer information found');
|
|
return $res->getReturnResponse();
|
|
}
|
|
|
|
// vehicles
|
|
$cv_list = [];
|
|
$cvs = $cust->getVehicles();
|
|
foreach ($cvs as $cv)
|
|
{
|
|
$battery_id = null;
|
|
if ($cv->getCurrentBattery() != null)
|
|
$battery_id = $cv->getCurrentBattery()->getID();
|
|
|
|
$wty_ex = null;
|
|
if ($cv->getWarrantyExpiration() != null)
|
|
$wty_ex = $cv->getWarrantyExpiration()->format('Y-m-d');
|
|
|
|
$cv_list[] = [
|
|
'id' => $cv->getID(),
|
|
'mfg_id' => $cv->getVehicle()->getManufacturer()->getID(),
|
|
'make_id' => $cv->getVehicle()->getID(),
|
|
'name' => $cv->getName(),
|
|
'plate_num' => $cv->getPlateNumber(),
|
|
'model_year' => $cv->getModelYear(),
|
|
'color' => $cv->getColor(),
|
|
'condition' => $cv->getStatusCondition(),
|
|
'fuel_type' => $cv->getFuelType(),
|
|
'wty_code' => $cv->getWarrantyCode(),
|
|
'wty_expire' => $wty_ex,
|
|
'curr_batt_id' => $battery_id,
|
|
'is_motolite' => $cv->hasMotoliteBattery() ? 1 : 0,
|
|
'is_active' => $cv->isActive() ? 1 : 0,
|
|
];
|
|
}
|
|
|
|
// data
|
|
$data = [
|
|
'vehicles' => $cv_list
|
|
];
|
|
$res->setData($data);
|
|
|
|
return $res->getReturnResponse();
|
|
}
|
|
|
|
public function listPromos(Request $req)
|
|
{
|
|
// check required parameters and api key
|
|
$required_params = [];
|
|
$em = $this->getDoctrine()->getManager();
|
|
$res = $this->checkParamsAndKey($req, $em, $required_params);
|
|
if ($res->isError())
|
|
return $res->getReturnResponse();
|
|
|
|
return $res->getReturnResponse();
|
|
}
|
|
|
|
public function getCompatibleBatteries(Request $req, $vid)
|
|
{
|
|
// check required parameters and api key
|
|
$required_params = [];
|
|
$em = $this->getDoctrine()->getManager();
|
|
$res = $this->checkParamsAndKey($req, $em, $required_params);
|
|
if ($res->isError())
|
|
return $res->getReturnResponse();
|
|
|
|
// get vehicle
|
|
$vehicle = $em->getRepository(Vehicle::class)->find($vid);
|
|
if ($vehicle == null)
|
|
{
|
|
$res->setError(true)
|
|
->setErrorMessage('Invalid vehicle');
|
|
return $res->getReturnResponse();
|
|
}
|
|
|
|
// batteries
|
|
$batt_list = [];
|
|
$batts = $vehicle->getBatteries();
|
|
foreach ($batts as $batt)
|
|
{
|
|
$batt_list[] = [
|
|
'id' => $batt->getID(),
|
|
'mfg_id' => $batt->getManufacturer()->getID(),
|
|
'mfg_name' => $batt->getManufacturer()->getName(),
|
|
'model_id' => $batt->getModel()->getID(),
|
|
'model_name' => $batt->getModel()->getName(),
|
|
'size_id' => $batt->getSize()->getID(),
|
|
'size_name' => $batt->getSize()->getName(),
|
|
'price' => $batt->getSellingPrice(),
|
|
'wty_private' => $batt->getWarrantyPrivate(),
|
|
'wty_commercial' => $batt->getWarrantyCommercial(),
|
|
];
|
|
}
|
|
|
|
// data
|
|
$data = [
|
|
'vehicle' => [
|
|
'id' => $vehicle->getID(),
|
|
'mfg_id' => $vehicle->getManufacturer()->getID(),
|
|
'mfg_name' => $vehicle->getManufacturer()->getName(),
|
|
'make' => $vehicle->getMake(),
|
|
'model_year_from' => $vehicle->getModelYearFrom(),
|
|
'model_year_to' => $vehicle->getModelYearTo(),
|
|
],
|
|
'batteries' => $batt_list,
|
|
];
|
|
$res->setData($data);
|
|
|
|
|
|
return $res->getReturnResponse();
|
|
}
|
|
|
|
public function requestJobOrder(Request $req)
|
|
{
|
|
// check required parameters and api key
|
|
$required_params = [];
|
|
$em = $this->getDoctrine()->getManager();
|
|
$res = $this->checkParamsAndKey($req, $em, $required_params);
|
|
if ($res->isError())
|
|
return $res->getReturnResponse();
|
|
|
|
return $res->getReturnResponse();
|
|
}
|
|
|
|
public function getEstimate(Request $req)
|
|
{
|
|
// check required parameters and api key
|
|
$required_params = [];
|
|
$em = $this->getDoctrine()->getManager();
|
|
$res = $this->checkParamsAndKey($req, $em, $required_params);
|
|
if ($res->isError())
|
|
return $res->getReturnResponse();
|
|
|
|
return $res->getReturnResponse();
|
|
}
|
|
}
|