private function createRefreshingTokenCreator($accessingCreator)
 {
     if (f\not($this->storage->hasRefreshTokenRepository())) {
         return $accessingCreator;
     }
     return new RefreshingTokenCreator($accessingCreator, $this->createRefreshTokenCreator());
 }
 private function getUserId(array $inputData)
 {
     if (f\not($inputData, 'user_id')) {
         throw new UserNotFoundException();
     }
     return f\get($inputData, 'user_id');
 }
 public function check(UserCredentials $userCredentials)
 {
     $user = $this->findUser($userCredentials->getUsername());
     if (f\not($user)) {
         return false;
     }
     return f\get($user, 'password') === $userCredentials->getPassword();
 }
 private function getToken($data)
 {
     $token = f\get($data, 'token');
     if (f\not(is_string($token))) {
         throw new \InvalidArgumentException('Token must be a strong.');
     }
     return $token;
 }
 public function resolve(Context $context)
 {
     if (f\not($context->getScopes()->isEmpty())) {
         return $context;
     }
     $defaultScopes = ScopeCollection::createFromString(f\get($context->getClient(), 'defaultScope'));
     return new Context($context->getClient(), $context->getUserId(), $defaultScopes);
 }
Exemple #6
0
/**
 * f\rename_keys($coll, $keysMap)
 *
 * Returns a new coll with the keys from keysMap renamed.
 *
 * f\rename_keys(array('a' => 1, 'b' => 2), array('a' => 'c', 'b' => 'd'))
 * => array('c' => 1, 'd' => 2)
 */
function rename_keys($coll, $keysMap)
{
    if (f\not($keysMap)) {
        return $coll;
    }
    $from = f\first(f\keys($keysMap));
    $to = f\first($keysMap);
    return f\rename_keys(f\rename_key($coll, $from, $to), f\dissoc($keysMap, $from));
}
 private function findUser($username)
 {
     $getUser = function ($user) use($username) {
         return f\get($user, 'username') === $username;
     };
     $user = f\find($getUser, $this->users);
     if (f\not($user)) {
         throw new UserNotFoundException();
     }
     return $user;
 }
 /**
  * @return array
  */
 public function obtain(Request $request)
 {
     if (f\not($request->headers->has('authorization'))) {
         throw new AccessTokenDataNotFoundOAuthErrorException();
     }
     $authorization = $request->headers->get('authorization');
     $regex = '/^Bearer (.+)$/';
     if (f\not(preg_match($regex, $authorization))) {
         throw new AccessTokenDataNotFoundOAuthErrorException();
     }
     $token = preg_replace($regex, '$1', $authorization);
     return array('token' => $token);
 }
Exemple #9
0
/**
 * f\normalize_coll($coll, $normalizers)
 *
 * Returns a new collection normalizing the elements indicating in normalizers.
 * It accepts param rules as normalizers.
 * It's similar to map_indexed.
 *
 * f\normalize_coll(array('a' => 1.0), array('a' => 'intval'));
 * => array('a' => 1)
 *
 * // elements without normalizers are returned without modification
 * f\normalize_coll(array('a' => 1.0, 'b' => 2.0), array('a' => 'intval'));
 * => array('a' => 1, 'b' => 2.0)
 *
 * // with param rules
 * f\normalize_coll(array('a' => 1.0), array('a' => f\required('normalizer' => 'intval')));
 * => array('a' => 1)
 */
function normalize_coll($collection, $normalizers)
{
    $result = f\to_array($collection);
    foreach ($normalizers as $name => $normalizer) {
        if ($normalizer instanceof param_rule) {
            $normalizer = $normalizer->getNormalizer();
            if (f\not($normalizer)) {
                continue;
            }
        }
        $result[$name] = call_user_func($normalizer, f\get($collection, $name));
    }
    return $result;
}
Exemple #10
0
/**
 * f\fill($coll, $paramRules)
 *
 * Returns a new collection filled with param rules.
 * If a param is optional and it does not exist and there is a default value, it's filled.
 * If a param exists and there is no param rule for that param, it's not filled.
 *
 * // filling with empty coll
 * f\fill(array(), array('a' => f\optional(array('d' => 1)));
 * => array('a' => 1)
 *
 * // filling with existing coll
 * f\fill(array('a' => 1), array('a' => f\required(), 'b' => f\optional(array('d' => 2)));
 * => array('a' => 1, 'b' => 2)
 *
 * // without param rule
 * f\fill(array('a' => 1, 'b' => 2), array('a' => f\required()));
 * => array()
 */
function fill($coll, $paramRules)
{
    $fill = function ($rule, $key) use($coll) {
        if (f\not($rule instanceof param_rule)) {
            throw new \InvalidArgumentException('Fill rules must be created with felpado\\required and felpado\\optional.');
        }
        if ($rule instanceof optional) {
            $value = f\get_or($coll, $key, $rule->getDefaultValue());
        } else {
            $value = f\get($coll, $key);
        }
        return $value;
    };
    return f\map_indexed($fill, $paramRules);
}
Exemple #11
0
/**
 * f\assoc_in($coll, $in, $value)
 *
 * Returns an array based on coll with value associated in the nested structure of in.
 *
 * f\assoc_in(array('a' => 1), array('b', 'b1'), 2);
 * => array('a' => 1, 'b' => array('b1' => 2))
 *
 * // does nothing without in
 * f\assoc_in(array('a' => 1), array(), 2);
 * => array('a' => 1)
 *
 * // supports infinite nesting
 * f\assoc_in(array(), array('a', 'a1', 'a1I', 'a1IA'), 1);
 * => array('a' => array('a1' => array('a1I' => array('a1IA' => 1))))
 */
function assoc_in($coll, $in, $value)
{
    if (empty($in)) {
        return $coll;
    }
    $array = f\to_array($coll);
    $current =& $array;
    foreach ($in as $k) {
        if (f\not(f\get_or($current, $k, null))) {
            $current = f\assoc($current, $k, array());
        }
        $current =& $current[$k];
    }
    $current = $value;
    return $array;
}
 private function getContext(Client $client, array $inputData)
 {
     if (f\not(f\contains($inputData, 'refresh_token'))) {
         throw new RefreshTokenNotFoundOAuthErrorException();
     }
     $refreshToken = $this->refreshTokenRepository->find(f\get($inputData, 'refresh_token'));
     if (f\not($refreshToken)) {
         throw new InvalidRefreshTokenOAuthErrorException();
     }
     if ($refreshToken->isExpired()) {
         throw new ExpiredRefreshTokenOAuthErrorException();
     }
     $accessToken = $this->accessTokenRepository->find(f\get($refreshToken, 'accessTokenToken'));
     if (f\not($accessToken)) {
         $this->refreshTokenRepository->remove($refreshToken);
         throw new InvalidRefreshTokenOAuthErrorException();
     }
     $this->refreshTokenRepository->remove($refreshToken);
     $this->accessTokenRepository->remove($accessToken);
     return new Context($client, f\get($accessToken, 'userId'), ScopeCollection::createFromString(f\get($accessToken, 'scope')));
 }
Exemple #13
0
/**
 * f\validate_coll($coll, $paramRules)
 *
 * Returns the validation errors when validating coll with param rules.
 *
 * // validating existence
 * f\validate_coll(array(), array('a' => f\required(), 'b' => f\optional()));
 * => array('a' => 'required')
 *
 * // multiple errors
 * f\validate_coll(array(), array('a' => f\required(), 'b' => f\required()));
 * => array('a' => 'required', 'b' => 'required')
 *
 * // validator fn
 * f\validate_coll(array('a' => 1.0), array('a' => f\required('v' => 'is_int')));
 * => array('a' => 'invalid')
 *
 * // without errors
 * f\validate_coll(array('a' => 1), array('a' => f\required('v' => 'is_int')));
 * => array()
 */
function validate_coll($coll, $paramRules)
{
    $validate = function ($paramRule, $key) use($coll) {
        if (f\not($paramRule instanceof param_rule)) {
            throw new \InvalidArgumentException('Param rules must be created with felpado\\required and felpado\\optional.');
        }
        if (f\contains($coll, $key)) {
            if ($paramRule->getValidator()) {
                $value = f\get($coll, $key);
                if (f\not(is_null($value) && $paramRule instanceof optional)) {
                    $isValid = f\validate($value, $paramRule->getValidator());
                    if (f\not($isValid)) {
                        return 'invalid';
                    }
                }
            }
        } elseif ($paramRule instanceof required) {
            return 'required';
        }
        return null;
    };
    return f\filter_indexed('felpado\\identity', f\map($validate, $paramRules));
}
Exemple #14
0
 /**
  * @dataProvider provideNotFalse
  */
 public function testNotFalse($value)
 {
     $this->assertFalse(f\not($value));
 }
 /**
  * @Then /^the response content should match "([^"]*)"$/
  */
 public function theResponseContentShouldNotMatch($regex)
 {
     $content = $this->getResponse()->getContent();
     if (f\not(preg_match($regex, $content))) {
         throw new Exception(sprintf('The response content is "%s" and it should match "%s", but it does not.', $content, $regex));
     }
 }
 /**
  * @When /^I try to grant a token with the client "([^"]*)" and the user id "([^"]*)" and the scope "([^"]*)"$/
  */
 public function iTryToGrantATokenWithTheClientAndTheUserIdAndTheScope($clientName, $userId, $scope)
 {
     $client = $this->findClientByName($clientName);
     $this->apiContext->addHttpBasicAuthentication(f\get($client, 'id'), f\get($client, 'secret'));
     $inputData = ['grant_type' => 'direct', 'user_id' => $userId];
     if (f\not(is_null($scope))) {
         $inputData = f\assoc($inputData, 'scope', $scope);
     }
     f\each(function ($v, $k) {
         $this->getApiContext()->addRequestParameter($k, $v);
     }, $inputData);
     $this->iMakeAOauthTokenRequest();
 }
 /**
  * @Given /^the container should has the service "([^"]*)"$/
  */
 public function theContainerShouldHasTheService($id)
 {
     if (f\not($this->getContainer()->has($id))) {
         throw new \Exception(sprintf('The container should have the service "%s but it does not.', $id));
     }
 }
 private function hasNoUserCredentialsInInputData($inputData)
 {
     return f\not(f\contains($inputData, 'username')) || f\not(f\contains($inputData, 'password'));
 }