public function update(Request $request, $id)
 {
     $categoria = Category::findOrFail($id);
     $categoria->fill($request->all());
     $categoria->save();
     return $this->success('Categoria atualizado');
 }
 public function update(Request $request, $id)
 {
     $user = User::findOrFail($id);
     $user->fill($request->all());
     $user->save();
     return $this->success('User atualizado');
 }
 /**
  * @param Request $request
  * @param array   $rules
  * @param array   $messages
  * @param array   $customAttributes
  */
 public function validate(Request $request, array $rules, array $messages = [], array $customAttributes = [])
 {
     $validator = $this->getValidationFactory()->make($request->all(), $rules, $messages, $customAttributes);
     if ($validator->fails()) {
         throw new ValidationHttpException($validator->errors());
     }
 }
 public function q(Request $request)
 {
     $search = $request->input("q");
     //todo: parse 'q' in separate class and return an array of parameters.
     //   See: https://developer.github.com/v3/search/#search-repositories
     $matches = [];
     //look specifically for field limiter 'in'
     $match = preg_match('/^(?<q>.*)\\bin:(?<in>.*)/us', $search, $matches[]);
     if ($match) {
         //just look for uri
         if (isset($matches[0]['in'])) {
             $fields = explode(',', $matches[0]['in']);
             foreach ($fields as $field) {
                 if ('uri' == $field) {
                     //lookup the uri in elements
                     $element = $this->elementRepository->findBy('uri', $matches[0]['q']);
                     if ($element) {
                         return $this->sendResponse($element->toArray(), "element found");
                     }
                     //lookup the uri in concepts
                     $concept = $this->conceptRepository->findBy('uri', $matches[0]['q']);
                     if ($concept) {
                         return $this->sendResponse($concept->toArray(), "concept found");
                     }
                 } else {
                 }
             }
         }
     }
 }
 public function update(Request $request, $id)
 {
     $restaurant = Restaurant::findOrFail($id);
     $restaurant->fill($request->all());
     $restaurant->save();
     return $this->success('Restaurante atualizado');
 }
 public function update(Request $request, $category_id, $item_id)
 {
     $item = Item::findOrFail($item_id);
     $item->fill($request->all());
     $item->save();
     return $this->success('Item atualizado');
 }
 public function update(Request $request, $order_id)
 {
     $order = Order::findOrFail($order_id);
     $order->fill($request->all());
     $order->save();
     return $this->success('Pedido atualizado');
 }
Exemple #8
0
 /**
  * Authenticate user with credentials.
  *
  * @param Request $request
  * @return \Symfony\Component\HttpFoundation\Response
  */
 public function login(Request $request)
 {
     $credentials = $request->only('email', 'password');
     if (!($token = $this->auth->attempt($credentials))) {
         return response()->json(['error' => 'invalid_credentials'], 401);
     }
     $user = $this->auth->setToken($token)->toUser();
     return response()->json(['data' => compact('token', 'user')]);
 }
 public function login(Request $request)
 {
     $credentials = $request->only('email', 'password');
     try {
         // verify the credentials and create a token for the user
         if (!($token = JWTAuth::attempt($credentials))) {
             return $this->response->errorUnauthorized();
         }
     } catch (JWTException $e) {
         // something went wrong
         return $this->response->errorInternal();
     }
     return $this->response->array(['token' => $token]);
 }
Exemple #10
0
 function ACRequest(Request $request)
 {
     $this->apiUrl = "http://ac.firefly.cc/";
     $authenticator = new AcAuth("Firefly Digital", "AC Web Timer", "*****@*****.**", "&11Rebma", $this->apiUrl);
     $token = $authenticator->issueToken();
     if ($token instanceof AcToken) {
         $client = new AcClient($token);
         $params = $request->all();
         $request_type = $params['request_type'];
         $call = $params['path_info'];
         unset($params['path_info'], $params['request_type']);
         $response = $client->{$request_type}($call, $params);
         print json_encode($response->getJson());
     }
 }
Exemple #11
0
 /**
  * Execute the rate limiting for the given request.
  *
  * @param \Dingo\Api\Http\Request $request
  * @param int                     $limit
  * @param int                     $expires
  *
  * @return void
  */
 public function rateLimitRequest(Request $request, $limit = 0, $expires = 0)
 {
     $this->request = $request;
     // If the throttle instance is already set then we'll just carry on as
     // per usual.
     if ($this->throttle instanceof Throttle) {
         //
         // If the developer specified a certain amount of requests or expiration
         // time on a specific route then we'll always use the route specific
         // throttle with the given values.
     } elseif ($limit > 0 || $expires > 0) {
         $this->throttle = new Route(['limit' => $limit, 'expires' => $expires]);
         $this->keyPrefix = md5($request->path());
         // Otherwise we'll use the throttle that gives the consumer the largest
         // amount of requests. If no matching throttle is found then rate
         // limiting will not be imposed for the request.
     } else {
         $this->throttle = $this->getMatchingThrottles()->sort(function ($a, $b) {
             return $a->getLimit() < $b->getLimit();
         })->first();
     }
     if (is_null($this->throttle)) {
         return;
     }
     $this->prepareCacheStore();
     $this->cache('requests', 0, $this->throttle->getExpires());
     $this->cache('expires', $this->throttle->getExpires(), $this->throttle->getExpires());
     $this->cache('reset', time() + $this->throttle->getExpires() * 60, $this->throttle->getExpires());
     $this->increment('requests');
 }
 public function backend(Request $request)
 {
     // grab credentials from the request
     $credentials = $request->only('email', 'password');
     try {
         // attempt to verify the credentials and create a token for the user
         if (!($token = $this->auth->attempt($credentials))) {
             return response()->json(['error' => 'invalid_credentials'], 401);
         }
     } catch (JWTException $e) {
         // something went wrong whilst attempting to encode the token
         return response()->json(['error' => 'could_not_create_token'], 500);
     }
     // all good so return the token
     return response()->json(compact('token'));
 }
Exemple #13
0
 /**
  * Boot the service provider.
  *
  * @author Morten Rugaard <*****@*****.**>
  *
  * @return void
  */
 public function boot()
 {
     // Set response static instances
     $this->setResponseStaticInstances();
     // Configure the "Accept"-header parser
     DingoHttpRequest::setAcceptParser($this->app['Dingo\\Api\\Http\\Parser\\Accept']);
     // Rebind API router
     $this->app->rebinding('api.routes', function ($app, $routes) {
         $app['api.url']->setRouteCollections($routes);
     });
     // Initiate HTTP kernel
     $kernel = $this->app->make('Illuminate\\Contracts\\Http\\Kernel');
     /// Add middlewares to HTTP request
     $this->app[NodesHttpMiddlewareRequest::class]->mergeMiddlewares($this->gatherAppMiddleware($kernel));
     // Prepend request middleware
     $this->addRequestMiddlewareToBeginning($kernel);
     // Replace route dispatcher
     $this->app['events']->listen(DingoEventRequestWasMatched::class, function (DingoEventRequestWasMatched $event) {
         $this->replaceRouteDispatcher();
         $this->updateRouterBindings();
     });
     // Load project routes
     $this->loadRoutes();
     // Register namespace for API views
     $this->loadViewsFrom(__DIR__ . '/../resources/views', 'nodes.api');
     // Register publish groups
     $this->publishGroups();
 }
 protected function createRequest($uri, $method, array $headers = [])
 {
     $request = Request::create($uri, $method);
     foreach ($headers as $key => $value) {
         $request->headers->set($key, $value);
     }
     return $request;
 }
Exemple #15
0
 /**
  * Handle an incoming request.
  *
  * @param \Illuminate\Http\Request $request
  * @param \Closure                 $next
  *
  * @return mixed
  */
 public function handle($request, Closure $next)
 {
     if ($this->validator->validateRequest($request)) {
         $request = HttpRequest::createFromExisting($request);
         return $this->sendRequestThroughRouter($request);
     }
     return $next($request);
 }
Exemple #16
0
 /**
  * Boot the service provider.
  *
  * @return void
  */
 public function boot()
 {
     $this->setResponseStaticInstances();
     Request::setAcceptParser($this->app['Dingo\\Api\\Http\\Parser\\Accept']);
     $this->app->rebinding('api.routes', function ($app, $routes) {
         $app['api.url']->setRouteCollections($routes);
     });
 }
 public function testProvidersAreFilteredWhenSpecificProviderIsRequested()
 {
     $this->router->shouldReceive('getCurrentRoute')->once()->andReturn($route = m::mock('Dingo\\Api\\Routing\\Route'));
     $this->router->shouldReceive('getCurrentRequest')->once()->andReturn($request = Request::create('foo', 'GET'));
     $provider = m::mock('Dingo\\Api\\Auth\\Provider\\Provider');
     $provider->shouldReceive('authenticate')->once()->with($request, $route)->andReturn((object) ['id' => 1]);
     $this->auth->extend('one', m::mock('Dingo\\Api\\Auth\\Provider\\Provider'));
     $this->auth->extend('two', $provider);
     $this->auth->authenticate(['two']);
     $this->assertEquals($provider, $this->auth->getProviderUsed());
 }
 public function testControllerOptionsMergeAndOverrideRouteOptions()
 {
     $request = Request::create('foo', 'GET');
     $route = new Route($this->adapter, $this->container, $request, ['uri' => 'foo', 'methods' => ['GET', 'HEAD'], 'action' => ['scopes' => ['foo', 'bar'], 'providers' => ['foo'], 'limit' => 5, 'expires' => 10, 'throttle' => 'Foo', 'version' => ['v1'], 'conditionalRequest' => false, 'uses' => 'Dingo\\Api\\Tests\\Stubs\\RoutingControllerStub@index']]);
     $this->assertEquals(['foo', 'bar', 'baz', 'bing'], $route->scopes(), 'Route did not setup scopes correctly.');
     $this->assertEquals(['foo', 'red', 'black'], $route->getAuthProviders(), 'Route did not setup authentication providers correctly.');
     $this->assertEquals(10, $route->getRateLimit(), 'Route did not setup rate limit correctly.');
     $this->assertEquals(20, $route->getRateExpiration(), 'Route did not setup rate limit expiration correctly.');
     $this->assertTrue($route->hasThrottle(), 'Route did not setup throttle correctly.');
     $this->assertInstanceOf('Dingo\\Api\\Tests\\Stubs\\BasicThrottleStub', $route->getThrottle(), 'Route did not setup throttle correctly.');
 }
 /**
  * @expectedException \Symfony\Component\HttpKernel\Exception\UnauthorizedHttpException
  */
 public function testAuthenticationFailsAndExceptionIsThrown()
 {
     $exception = new UnauthorizedHttpException('test');
     $request = Request::create('test', 'GET');
     $route = new Route($this->adapter, $this->container, $request, ['uri' => '/test', 'action' => ['providers' => []]]);
     $this->auth->shouldReceive('check')->once()->with(false)->andReturn(false);
     $this->auth->shouldReceive('authenticate')->once()->with([])->andThrow($exception);
     $this->router->shouldReceive('getCurrentRoute')->once()->andReturn($route);
     $this->middleware->handle($request, function () {
         //
     });
 }
 /**
  * Boot the service provider.
  *
  * @return void
  */
 public function boot()
 {
     $this->setupConfig();
     Http\Response::setFormatters($this->prepareConfigValues($this->app['config']['api.formats']));
     Http\Response::setTransformer($this->app['api.transformer']);
     Http\Response::setEventDispatcher($this->app['events']);
     $config = $this->app['config']['api'];
     Http\Request::setAcceptParser(new Http\Parser\Accept($config['standardsTree'], $config['subtype'], $config['version'], $config['defaultFormat']));
     $this->app->rebinding('api.routes', function ($app, $routes) {
         $app['api.url']->setRouteCollections($routes);
     });
 }
 public function authenticate(Request $request, UserRepository $userRepository)
 {
     // grab credentials from the request
     $credentials = $request->only('email', 'password');
     // TODO Move user authentication code somewhere more appropriate
     $previousException = null;
     if ($credentials["email"] === null) {
         $previousException = new NotFoundHttpException("User not found.", null, 0xc00101);
     }
     if ($credentials["password"] === null) {
         // TODO Test after code \Eos\Exceptions\Factory::collection()
         throw new NotFoundHttpException("User not found.", $previousException, 0xc00102);
     } else {
         if ($previousException !== null) {
             throw $previousException;
         }
     }
     // Try to find user by email
     $user = $userRepository->findWhere(["email" => $credentials["email"]]);
     if (count($user) === 0) {
         // The user could not found by that email
         throw new NotFoundHttpException("User not found.", null, 0xc00103);
     }
     /**
      * @var \Eos\Entities\User $user
      */
     $user = $user[0];
     if (!Hash::check($credentials["password"], $user->password)) {
         // Password mismatch
         throw new NotFoundHttpException("User not found.", null, 0xc00104);
     }
     try {
         $token = JWTAuth::fromUser($user);
     } catch (JWTException $exception) {
         throw new \Exception("Couldn't create token", 0xc00105);
     }
     return response()->json(["token" => $token, "user" => ["first_name" => $user->first_name, "middle_name" => $user->middle_name, "last_name" => $user->last_name, "email" => $user->email]]);
 }
 public function update(Request $request, $id)
 {
     $validator = \Validator::make($request->all(), ['id' => 'required', 'email' => 'required|email|unique:users', 'name' => 'required', 'password' => 'min:6']);
     if ($validator->fails()) {
         throw new StoreResourceFailedException('Could not able to update user.', $validator->errors());
     }
     $user = User::findorfail($id);
     $user->email = $request->get('email');
     $user->name = $request->get('name');
     if ($request->get('password')) {
         $user->password = Hash::make($request->get('password'));
     }
     if ($user->save()) {
         return $this->response->array(['message' => 'User has been updated successfully', 'status' => 200]);
     } else {
         return $this->response->array(['message' => 'Unable to update user. Please try again', 'status' => 200]);
     }
 }
Exemple #23
0
 /**
  * Gather the middlewares for the route.
  *
  * @param \Dingo\Api\Http\Request $request
  *
  * @return array
  */
 protected function gatherRouteMiddlewares($request)
 {
     if ($route = $request->route()) {
         return $this->router->gatherRouteMiddlewares($route);
     }
     return [];
 }
 public function testAdapterDispatchesRequestsThroughRouter()
 {
     $this->container['request'] = Http\Request::create('/foo', 'GET');
     $this->router->version('v1', function () {
         $this->router->get('foo', function () {
             return 'foo';
         });
     });
     $response = $this->router->dispatch($this->container['request']);
     $this->assertEquals('foo', $response->getContent());
 }
 /**
  * Handle an incoming request.
  *
  * @param  \Dingo\Api\Http\Request  $request
  * @param  \Closure  $next
  * @return mixed
  */
 public function handle($request, Closure $next)
 {
     $search = $request->input('q');
     $bar = $request->getQueryString();
     return $next($request);
 }
 function declineUser(Request $request)
 {
     $data = $request->only('token');
     \DB::table('tmp_users')->where('token', '=', $data['token'])->delete();
     return $this->response->noContent();
 }
Exemple #27
0
 /**
  * Parse the includes.
  *
  * @param \Dingo\Api\Http\Request $request
  *
  * @return void
  */
 public function parseFractalIncludes(Request $request)
 {
     $includes = $request->get($this->includeKey);
     if (!is_array($includes)) {
         $includes = array_filter(explode($this->includeSeparator, $includes));
     }
     $this->fractal->parseIncludes($includes);
 }
 public function testGettingTheRemainingLimit()
 {
     $this->limiter->extend(new ThrottleStub(['limit' => 10, 'expires' => 200]));
     $this->limiter->rateLimitRequest(Request::create('test', 'GET'));
     $this->assertEquals(9, $this->limiter->getRemainingLimit());
 }
 public function testExceptionsHandledByRenderAreReroutedThroughHandler()
 {
     $request = ApiRequest::create('foo', 'GET');
     $this->log->shouldReceive('error')->once()->with($exception = new HttpException(404));
     $response = $this->exceptionHandler->render($request, $exception);
     $this->assertEquals('{"message":"404 Not Found","status_code":404}', $response->getContent());
 }
 public function testRateLimitingWithRouteThrottle()
 {
     $request = Request::create('test', 'GET');
     $route = m::mock('Dingo\\Api\\Routing\\Route');
     $route->shouldReceive('hasThrottle')->once()->andReturn(true);
     $route->shouldReceive('getThrottle')->once()->andReturn(new ThrottleStub(['limit' => 10, 'expires' => 20]));
     $route->shouldReceive('getRateLimit')->once()->andReturn(0);
     $route->shouldReceive('getRateExpiration')->once()->andReturn(0);
     $this->router->shouldReceive('getCurrentRoute')->once()->andReturn($route);
     $response = $this->middleware->handle($request, function ($request) {
         return new Response('foo');
     });
     $this->assertArrayHasKey('x-ratelimit-limit', $response->headers->all());
     $this->assertArrayHasKey('x-ratelimit-remaining', $response->headers->all());
     $this->assertArrayHasKey('x-ratelimit-reset', $response->headers->all());
     $this->assertEquals(9, $response->headers->get('x-ratelimit-remaining'));
     $this->assertEquals(10, $response->headers->get('x-ratelimit-limit'));
 }