public function translateRequest(\Neuron\Net\Request $request)
{
$headers = array();
foreach ($request->getHeaders() as $k => $v) {
$headers[strtoupper($k)] = $v;
}
return new \OAuth2\Request($request->getParameters(), $request->getPost(), array(), $request->getCookies(), array(), array(), null, $headers);
}
public function setRequestUser(\Neuron\Net\Request $request)
{
$request->addUserCallback('oauth2', function (\Neuron\Net\Request $request) {
if (Verifier::isValid($request)) {
$userid = Verifier::getUserId();
$user = \Neuron\MapperFactory::getUserMapper()->getFromId($userid);
if ($user) {
return $user;
}
}
return null;
});
}
/**
* Handle a a set of routes: if a match is found, execute the relating handling function
* @param array $routes Collection of route patterns and their handling functions
* @throws InvalidParameter
* @return \Neuron\Net\Response The response
*/
private function handle($routes)
{
// The current page URL
$numHandled = 0;
// Loop all routes
foreach ($routes as $route) {
if (!$route instanceof Route) {
throw new InvalidParameter("Route contains invalid models.");
}
// we have a match!
if ($params = $this->request->parseRoute($route)) {
if (!is_array($params)) {
$params = array();
}
// call the handling function with the URL parameters
$this->handleMatch($route, $params);
//call_user_func_array($route['fn'], $params);
// yay!
$numHandled++;
// If we need to quit, then quit
//if ($quitAfterRun) break;
}
}
return $numHandled;
}
protected function setAdditionalParameters(DeligatedUser $user)
{
$steamKey = Config::get('accounts.steam.key');
if ($steamKey) {
$openid = $user->getUniqueId();
$params = explode('/', $openid);
$id = array_pop($params);
// Now fetch the user data
$request = new Request();
$request->setUrl('http://api.steampowered.com/ISteamUser/GetPlayerSummaries/v0002/');
$request->setParameters(array('key' => $steamKey, 'steamids' => $id));
$response = Client::getInstance()->get($request);
// No headers? No gain.
$data = json_decode($response->getBody(), true);
if ($data) {
$userdata = $data['response']['players'][0];
$user->setName($userdata['personaname']);
$user->setAvatar($userdata['avatarfull']);
$user->setFirstname($userdata['realname']);
$user->setUrl($userdata['profileurl']);
}
}
}
private function api(Request $request, $method)
{
$ch = curl_init();
$post = $request->getBody();
$parsedUrl = $request->getUrl();
if ($request->getParameters()) {
if (strpos($parsedUrl, '?')) {
$parsedUrl .= '&';
} else {
$parsedUrl .= '?';
}
$parsedUrl .= http_build_query($request->getParameters());
}
curl_setopt($ch, CURLOPT_URL, $parsedUrl);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HEADER, 1);
if ($request->getHeaders()) {
$headers = $request->getHeaders();
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
}
switch ($method) {
case 'GET':
break;
case 'POST':
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, $post);
break;
case 'DELETE':
throw new NotImplemented("Not implemented.");
break;
case 'PUT':
curl_setopt($ch, CURLOPT_PUT, 1);
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, $post);
break;
}
$output = curl_exec($ch);
// Response
$header_size = curl_getinfo($ch, CURLINFO_HEADER_SIZE);
$header = substr($output, 0, $header_size);
$body = substr($output, $header_size);
$response = Response::fromRaw($body, self::http_parse_headers($header));
curl_close($ch);
return $response;
}
/**
* @param $signedData
* @param $username
* @param $host
* @return mixed[]
* @throws KikSDKException
*/
public function decryptPayload($signedData, $username, $host)
{
$request = new Request();
$request->setUrl($this->apiUrl . 'verification/v1/check');
$request->setParameters(array('u' => $username, 'd' => $host, 'debug' => $this->debug ? 'true' : 'false'));
$request->setBody($signedData);
$request->setHeader('Content-Type', 'text/plain');
$httpClient = Client::getInstance();
$response = $httpClient->post($request);
if (!$response) {
throw new KikSDKException("Could not reach server");
}
return $response->getBody();
}
/**
* @param Request $request
* @throws DataNotSet
*/
public function dispatch(Request $request = null)
{
if ($this->isFirstDispatch) {
$this->isFirstDispatch = false;
$this->trigger('dispatch:first');
}
// Trigger initialize
$this->trigger('dispatch:initialize');
// Check locales
$this->checkLocale();
if (!isset($this->router)) {
throw new DataNotSet("Application needs a router.");
}
if (!isset($request)) {
$request = Request::fromInput();
}
// Set session from the session handler
$session = new Session($this->getSessionHandler());
$session->connect();
// Set session in request
$request->setSession($session);
// Trigger before
$this->trigger('dispatch:before', $request);
// Run router
$this->router->run($request);
// Trigger dispatch
$this->trigger('dispatch:after', $request);
// Disconnect the session
$session->disconnect();
// End
$this->trigger('dispatch:terminate');
}
/**
* Set user from session
* @param Request $request
*/
public function setRequestUser(Request $request)
{
$request->addUserCallback('accounts', function (Request $request) {
$userid = $request->getSession()->get('catlab-user-id');
if ($userid) {
$user = MapperFactory::getUserMapper()->getFromId($userid);
ExpectedType::check($user, User::class);
if ($user) {
if ($accessToken = $request->getSession()->get('catlab-openid-access-token')) {
$user->setAccessToken($accessToken);
}
return $user;
}
}
return null;
});
}
/**
* Called after a redirect
* @param Request $request
* @return Response
*/
public function postLogout(Request $request)
{
if ($redirect = $request->getSession()->get('post-login-redirect')) {
$request->getSession()->set('post-login-redirect', null);
$request->getSession()->set('cancel-login-redirect', null);
return Response::redirect($redirect);
}
return Response::redirect(URLBuilder::getURL('/'));
}
/**
* Proxy a request.
* @param string|Request $request Url or Request object.
* @return Response
*/
public static function proxy($request)
{
if (!$request instanceof Request) {
$url = $request;
$request = new Request();
$request->setUrl($url);
$request->setMethod(Request::METHOD_GET);
}
return Client::getInstance()->process($request);
}
