public function createUser(Request $request)
 {
     if ($request->isMethod('post')) {
         $user = new User();
         $errors = null;
         $user->firstname = $request->json('firstname');
         $user->lastname = $request->json('lastname');
         $user->email = $request->json('email');
         $user->facebookid = $request->json('facebookid');
         if ($user->firstname === null || $user->lastname === null) {
             $errors .= " no firstname or lastname supplied \n";
         }
         if ($user->facebookid === null) {
             $errors .= " no Facebook ID supplied \n";
         }
         if ($errors === null) {
             try {
                 $user->save();
             } catch (QueryException $e) {
                 //TODO check this is the correct error
                 return "Error, Facebook ID already in use ";
             }
         } else {
             return "Error," . $errors;
         }
         $user->token()->save($this->newToken());
         return json_encode(["userid" => $user->id, "AuthToken" => $user->token->api_token]);
     } else {
         return response('Invalid request', 405)->header('Allow', 'POST');
     }
 }
 /**
  * Update the specified resource in storage.
  *
  * @param  \Illuminate\Http\Request $request
  *
  * @return \Illuminate\Http\Response
  *
  */
 public function store(Request $request)
 {
     // Read subscriber details
     $uuid = $request->json('uuid');
     $latitude = $request->json('latitude');
     $longitude = $request->json('longitude');
     // Validate latitude/longitude
     if (!is_numeric($latitude)) {
         return response()->json(['message' => "Latitude must be a number."], Response::HTTP_BAD_REQUEST);
     }
     if (!is_numeric($longitude)) {
         return response()->json(['message' => "Longitude must be a number."], Response::HTTP_BAD_REQUEST);
     }
     // Check if user is already subscribed
     $repository = SubscriberRepository::getInstance();
     $subscriber = $repository->getByUuid($uuid);
     if (!empty($subscriber)) {
         return response()->json(['message' => "Already subscribed."], Response::HTTP_BAD_REQUEST);
     }
     $subscriber = new Subscriber();
     $subscriber->setUuid($uuid);
     $subscriber->setLatitude(doubleval($latitude));
     $subscriber->setLongitude(doubleval($longitude));
     try {
         $subscriber->save();
     } catch (QueryException $exception) {
         return response()->json(['message' => "Oops, something went wrong."], Response::HTTP_INTERNAL_SERVER_ERROR);
     }
     return response()->json([], Response::HTTP_CREATED);
 }
 public function postReading(Request $request)
 {
     $therm = Thermostat::where('guid', $request->json('guid'))->first();
     $reading = $therm->readings()->create(array());
     $reading->temperature = $request->json('temperature');
     $reading->humidity = $request->json('humidity');
     $reading->save();
 }
 /**
  * Insert new organizations to the database
  *
  * @param Request $request
  * @param RelationInserter $inserter
  * @return Response
  */
 public function store(Request $request, RelationInserter $inserter)
 {
     // Check for valid / not empty request body
     if (!$request->json()->all()) {
         return response('', 400);
     }
     $inserter->insert($request->json()->all());
     return response('', 201);
 }
 public function update(Request $req, JsonResponse $res, $id)
 {
     $type = $req->json('data.type');
     $attrs = $req->json('data.attributes');
     $game = $this->game->find($id);
     $game->fill($attrs);
     $game->save();
     return new JsonResponse(['data' => $this->serializeGame($game)]);
 }
 public function calculator(Request $request, $id)
 {
     $logistics = Logistics::findOrFail($id);
     $package = new Package();
     $items = $request->json()->get('items', []);
     foreach ($items as $index => $item) {
         $package->add($item);
     }
     $package->to($request->json()->get('to'));
     return ['price' => $logistics->deliverer->calc($package)];
 }
 public function update(Request $request, $id)
 {
     $admin = Admin::findOrFail($id);
     $admin->fill(array_except($request->json()->all(), 'roles'));
     $admin->save();
     if ($roles = array_filter($request->json()->get('roles'))) {
         $admin->roles()->detach();
         if (!empty($roles)) {
             $admin->roles()->attach($roles);
         }
     }
     return response()->updated($admin);
 }
 /**
  * @author WN
  * @param $installation
  * @param Request $request
  * @return \Illuminate\Http\JsonResponse
  */
 public function catchNotification($installation, Request $request)
 {
     try {
         $application = $this->notificationCatcherService->catchNotification($request->json('application'), $installation);
         if ($application->location !== null && $request->json('new_status') == 'converted' && $application->location->converted_email) {
             $this->locationNotificationService->convertedNotification($application, $application->location);
         }
         return response()->json(['local_id' => $application->id, 'current_status' => $application->ext_current_status], 200);
     } catch (\Exception $e) {
         $this->logError('CatchNotification: Failed with message: ' . $e->getMessage());
         return response()->json(['message' => $e->getMessage()], 400);
     }
 }
 public function refund(Request $request, $sn)
 {
     $order = $this->resources->where('sn', '=', $sn)->where('user_id', '=', $request->user->id)->firstOrFail();
     if ($order->order_status == Order::STATUS_COMPLETED) {
         \DB::transaction(function () use($sn, $request, $order) {
             $order->refund($request->json()->all())->logs()->save(new OrderLog(['do' => 'refund', 'name' => $request->user->name, 'comment' => $request->json()->get('comment')]));
         });
     } else {
         \DB::transaction(function () use($sn, $request, $order) {
             $order->refundAndCancel($request->json()->get('reason'))->logs()->save(new OrderLog(['do' => 'refund_and_cancel', 'name' => $request->user->name, 'comment' => $request->json()->get('comment')]));
         });
     }
     return response()->updated($order);
 }
 public function submit(Request $request)
 {
     if (!$request->ajax()) {
         throw new MethodNotAllowedHttpException();
     }
     if (!$request->has('contact_data') || !$request->has('test_data')) {
         return response()->json(['result' => 'failure', 'message' => 'Sorry, something went wrong...']);
     }
     $contactData = $request->json('contact_data');
     $testData = $request->json('test_data');
     $quizEntry = new Quiz(['name' => $contactData['name'], 'email' => $contactData['email'], 'telephone' => $contactData['telephone'], 'test_type' => 'new_student', 'answered' => $testData['answered'], 'correct' => $testData['correct'], 'failed' => $testData['failed'], 'level_title' => $testData['level_title']]);
     $quizEntry->save();
     return response()->json(['result' => 'success', 'redirect' => '/quiz/success'])->withCookie(cookie('passed_test_result', $testData['level_title'], 120));
 }
 /**
  * Creates the site
  *
  * @return Response
  */
 public function create(Request $request)
 {
     // get request
     $name = $request->json()->get('name');
     $theme = $request->json()->get('theme');
     $email = $request->json()->get('email');
     $password = $request->json()->get('password');
     $passcode = $request->json()->get('passcode');
     if ($passcode == env('PASSCODE')) {
         $arr = Site::create($name, $theme, $email, $password);
         return response()->json($arr);
     } else {
         return response('Passcode invalid', 401);
     }
 }
 public function postSearchRecipes(Request $request)
 {
     AlbertHeijn::setApiKey(env('API_KEY_ALBERTHEIJN'));
     $products = $request->json()->get('products');
     // Filters
     $filters = array();
     if ($request->json()->has('receptvleesvisofvega')) {
         $filters['receptvleesvisofvega'] = $request->json()->get('receptvleesvisofvega');
     }
     if ($request->json()->has('receptallergeneninfo')) {
         $filters['receptallergeneninfo'] = $request->json()->get('receptallergeneninfo');
     }
     $recipes = AlbertHeijn::searchRecipes($products, $filters);
     return response()->json($recipes);
 }
 public function updateConductoresEnTurno(Request $request, $ruta_id)
 {
     $noty = new NotificacionController();
     $data = $request->json()->all();
     $turnos_actuales = [];
     $ruta = Ruta::find($ruta_id);
     foreach ($data['turnos'] as $turno) {
         $turnos_actuales[$turno['conductor_id']] = ['turno' => $turno['turno']];
     }
     if ($ruta->toUpdateTurnos()->sync($turnos_actuales)) {
         $ruta = $ruta->destino->ciudad;
         foreach ($data['turnos'] as $turno) {
             if ($request['accion'] == 'agregar') {
                 $mensaje = "Has sido agregado a la ruta hacia {$ruta->nombre} en el turno " . $turno['turno'];
                 $noty->enviarNotificacionConductores($mensaje, $turno['conductor_id'], 'Actualizacion turno', $ruta_id);
             }
             if ($request['accion'] == 'quitar') {
                 $mensaje = "Has sido removido de los turnos de la ruta hacia {$ruta->nombre}";
                 $noty->enviarNotificacionConductores($mensaje, $turno['conductor_id'], 'Actualizacion turno', $ruta_id);
             }
             if ($request['accion'] == 'default') {
                 $mensaje = "Estas en el turno " . $turno['turno'] . " en la ruta hacia {$ruta->nombre}";
                 $noty->enviarNotificacionConductores($mensaje, $turno['conductor_id'], 'Actualizacion turno', $ruta_id);
             }
         }
         return response()->json(['mensaje' => 'turnos modifcados'], 201);
     } else {
         return response()->json(['mensajError' => 'error al actualizar lso turnos'], 400);
     }
 }
 /**
  * Update the specified resource in storage.
  *
  * @param  \Illuminate\Http\Request  $request
  * @param  int  $id
  * @return \Illuminate\Http\Response
  */
 public function update(Request $request, $id)
 {
     try {
         $data = $request->json()->all();
         unset($data['empresa']);
         unset($data['vehiculo']);
         $conductor = Conductor::find($id);
         if ($conductor) {
             //                actualizo los campos del conductor
             foreach ($data as $campo => $valor) {
                 $conductor->{$campo} = $valor;
             }
             if ($conductor->save()) {
                 if ($request->estado == 'Disponible') {
                     \App::make('\\App\\Events\\UpdatedEstadoConductorEvent')->enviarNotificacion("Notificacion", "El conductor {$conductor->nombres}" . " {$conductor->apellidos} se ha reportado como {$conductor->estado}", $conductor, $conductor->central_id);
                 } else {
                     \App::make('\\App\\Events\\UpdatedEstadoConductorEvent')->enviarNotificacion("Notificacion", "El conductor {$conductor->nombres}" . " {$conductor->apellidos} se ha reportado como {$conductor->estado}", $conductor, $conductor->central_id);
                 }
                 return JsonResponse::create(array('message' => "Actualizado Correctamente"), 200);
             } else {
                 return JsonResponse::create(array('message' => "No se pudo actualizar el registro"), 400);
             }
         } else {
             return response()->json(['mensaje' => 'El conductor no existe'], 400);
         }
     } catch (Exception $e) {
         return JsonResponse::create(array('message' => "Se produjo una exepcion", "exception" => $e->getMessage()), 401);
     }
 }
Exemple #15
0
 public function authenticate(Request $request)
 {
     $credentials = $request->json()->all();
     if (!($user = Auth::attempt($credentials, $request->has('remember')))) {
         return false;
     }
     $user = Auth::user();
     $key = config('jwt.key');
     $signer = new Sha256();
     $builder = (new Builder())->setIssuer(config('jwt.host'))->set('uid', $user->id);
     if (config('jwt.payload')['aud']) {
         $builder->setAudience($request->server('REMOTE_ADDR'));
     }
     if (config('jwt.payload')['iss']) {
         $builder->setIssuedAt(time());
     }
     if (config('jwt.payload')['nbf']) {
         $builder->setNotBefore(time() + config('jwt.not_before_time'));
     }
     if (config('jwt.payload')['exp']) {
         $builder->setExpiration(time() + config('jwt.expires'));
     }
     $token = $builder->sign($signer, $key)->getToken();
     return $token->__toString();
 }
 /**
  * add or edit project hook settings
  * @param [Request] $request HTTP Request
  *
  * @link(http://doc.gitlab.com/ce/api/projects.html#add-project-hook, link)
  */
 public function addOrEditProjectHooks(Request $request, $project_id = null)
 {
     $project = $request->json();
     if ($project_id == null) {
         $id = $project->get('project_id');
     } else {
         $id = $project_id;
     }
     // hook url
     $url = $project->get('url');
     $gitUrl = sprintf('projects/%d/hooks', $id);
     $json['url'] = $url;
     $json['push_events'] = $project->get('push_events') ?: true;
     $json['issues_events'] = $project->get('issues_events') ?: false;
     $json['merge_requests_events'] = $project->get('merge_requests_events') ?: true;
     $json['tag_push_events'] = $project->get('tag_push_events') ?: false;
     //dump($json);
     $client = new HttpClient();
     $method = 'POST';
     $hookId = null;
     if ($this->hookHasUrl($id, $project->get('url'), $hookId) == true) {
         Log::info("project '{$id}' hook('{$url}') is already exist..");
         $method = 'PUT';
         $gitUrl .= '/' . $hookId;
     }
     $response = $client->send($gitUrl, $json, $method);
     return json_encode($response, JSON_PRETTY_PRINT);
 }
 public function postSearchRecipes(Request $request)
 {
     AlbertHeijn::setApiKey(env('API_KEY_ALBERTHEIJN'));
     $products = $request->json()->get('products');
     $recipes = AlbertHeijn::searchRecipes($products);
     return response()->json($recipes);
 }
 public function store(Request $request)
 {
     $resource = new $this->model($request->json()->all());
     $resource->user_id = $request->user->id;
     $resource->save();
     return response()->created($resource);
 }
 /**
  * Report a comment, photo, restaurant, or review
  *
  * @param Request $request
  * @return Response
  */
 public function addAction(Request $request)
 {
     $json_return = array();
     $data = $request->json()->get('Report');
     if ($data['type'] == CONSTANTS::PHOTO) {
         $photo = Photos::find($data['type_id']);
         if (!$photo) {
             $message = 'Photo not found or already deleted';
             return showErrorResponse($message, HTTP_ACCEPTED, CONSTANTS::ERROR_CODE_PHOTO_MISSING);
         }
         $is_existing_photo_report = Reported::isExistingPhotoReport($data['type_id'], $data['user_id']);
         if ($is_existing_photo_report) {
             $message = 'You have already reported this photo';
             return showErrorResponse($message, HTTP_ACCEPTED, CONSTANTS::ERROR_CODE_REPORTED_ALREADY);
         }
     }
     try {
         $report = new Reported();
         $report_object = $report->addReport($data);
         $json_return[KeyParser::data] = ModelFormatter::reportFormat($report_object);
     } catch (\Exception $e) {
         return showErrorResponse($e->getMessage());
     }
     return response()->json($json_return);
 }
 public function createUser(Request $request)
 {
     Log::debug("JWTAuthController.createUser.begin");
     try {
         $credentials = $request->json()->all();
         $credentials['password'] = Hash::make($credentials['password']);
         Log::debug("JWTAuthController.createUser:"******"JWTAuthController.createUser.exception:" . $e->getMessage());
         return response()->json($e->getMessage());
     }
     Log::debug("JWTAuthController.createUser.end");
     return response()->json('ok');
 }
Exemple #21
0
 /**
  * data field contains a json object
  */
 public function store(Request $request)
 {
     $data = $request->json();
     // error_log(print_r($data->get('origins'), true));
     // error_log('debug');
     // error_log(print_r($data, true));
     // error_log('here');
     $ride = new Ride();
     $ride->initiator = Auth::user()->id;
     $ride->save();
     $rideUser = new RideUser();
     $rideUser->ride_id = $ride->id;
     $rideUser->user_id = Auth::user()->id;
     $rideUser->save();
     $route = new Route();
     $route->ride_id = $ride->id;
     $directions = !empty($data->get('google_directions')) ? json_encode($data->get('google_directions')) : '';
     $route->direction = $directions;
     $route->user_id = Auth::user()->id;
     $route->state = 'accepted';
     $route->note = !empty($data->get('share_details')) && isset($data->get('share_details')['notes']) ? $data->get('share_details')['notes'] : '';
     $route->endTime = !empty($data->get('share_details')) && isset($data->get('share_details')['arrival_time']) ? $data->get('share_details')['arrival_time'] : '';
     $route->save();
     $ride->head = $route->id;
     $ride->save();
     foreach ($data->get('origins') as $point) {
         $addr = isset($point['formatted_address']) ? $point['formatted_address'] : '';
         RoutePoint::create(['route_id' => $route->id, 'placeId' => $point['google_place_id'], 'address' => $addr, 'location' => $point['longitude'] . ',' . $point['latitude'], 'name' => $point['name'], 'type' => 'start']);
     }
     foreach ($data->get('destinations') as $point) {
         $addr = isset($point['formatted_address']) ? $point['formatted_address'] : '';
         RoutePoint::create(['route_id' => $route->id, 'placeId' => $point['google_place_id'], 'address' => $addr, 'location' => $point['longitude'] . ',' . $point['latitude'], 'name' => $point['name'], 'type' => 'end']);
     }
     return Response::json(['status' => 'success', 'data' => DbUtil::serializeRide($ride)]);
 }
 public function addChildNode(Request $req, $id)
 {
     $node = NodeItem::where('id', '=', $id)->first();
     if ($node) {
         return $node->children()->create($req->json()->all());
     }
 }
 public function update(Request $request, $reviewId)
 {
     $input = $request->json();
     $review = $this->reviewRepository->find($reviewId);
     $this->reviewService->updateFromInput($review, $input);
     return response()->json((new ReviewSerializer())->one($review), HttpCodes::HTTP_OK);
 }
 public function login(Request $request)
 {
     $input = $request->json()->all();
     $validator = Validator::make($input, ['email' => 'required|email', 'password' => 'required', 'deviceId' => 'required']);
     if ($validator->fails()) {
         $error = $validator->errors()->all();
         return response()->json(['errorMessage' => [$error]], 404);
     }
     $deviceId = $input['deviceId'];
     $result = DB::table('users')->where('email', $input['email'])->first();
     if ($result && Hash::check($input['password'], $result->password)) {
         $res = DB::table('tokens')->where('deviceId', $deviceId)->first();
         if ($res) {
             $token = Token::find($res->id);
             $token->token = bin2hex(openssl_random_pseudo_bytes(64));
             $token->save();
         } else {
             DB::table('tokens')->insert(['token' => bin2hex(openssl_random_pseudo_bytes(64)), 'userId' => $result->id, 'deviceId' => $deviceId]);
         }
         $token = DB::table('tokens')->select('token')->where('userId', $result->id)->where('deviceId', $deviceId)->first();
         if ($token) {
             return response()->json($token);
         } else {
             return response()->json(['errorMessage' => 'login failed'], 404);
         }
     } else {
         return response()->json(['errorMessage' => 'this user not found'], 404);
     }
 }
 /**
  * @param \Illuminate\Http\Request $request
  *
  * @return static
  */
 public static function createFromRequest(Request $request)
 {
     $instance = new static();
     if (in_array($request->getMethod(), ['POST', 'PATCH', 'PUT'])) {
         $instance->input = $request->json();
     } else {
         $instance->input = $request->query;
     }
     if ($request->query->has('per_page')) {
         $instance->perPage = intval($request->query->get('per_page'));
     }
     if ($request->query->has('page')) {
         $instance->page = intval($request->query->get('page'));
     }
     $instance->query = $request->query;
     $instance->apiClass = explode('@', $request->route()[1]['uses'])[0];
     $instance->method = $request->getMethod();
     $instance->headers = $request->headers;
     $instance->token = static::getToken($request);
     $instance->callback = $request->query->get('callback');
     $params = $request->route()[2];
     if (isset($params['id'])) {
         $id = intval($params['id']);
         $instance->resourceId = $id > 0 ? $id : null;
     }
     return $instance;
 }
 protected function processMany(Request $request, $id, $method)
 {
     $parent = $this->findParentEntity($id);
     $requestCollection = $request->json()->all();
     $this->validateRequestCollection($requestCollection, $this->getChildModel(), true);
     $existingChildren = $this->findChildrenCollection($requestCollection, $parent);
     $childModels = $this->fillModels($this->getChildModel(), $existingChildren, $requestCollection);
     $this->checkPermission(static::class . '@' . $method . 'Many', ['model' => $parent, 'children' => $childModels]);
     $this->preSync($parent, $childModels);
     $this->saveNewItemsInCollection($childModels);
     /** @var ElasticSearchIndexer $searchIndexer */
     $searchIndexer = app(ElasticSearchIndexer::class);
     $reindexItems = $searchIndexer->mergeUniqueCollection($searchIndexer->getAllItemsFromRelations($parent, [$this->relationName]), $childModels);
     $this->getRelation($parent)->{$method}($this->makeSyncList($childModels, $requestCollection));
     $this->postSync($parent, $childModels);
     // Reindex parent entity without relations
     $searchIndexer->reindexOne($parent, []);
     // Reindex all affected items without relations
     $searchIndexer->reindexMany($reindexItems, []);
     $transformed = $this->getTransformer()->transformCollection($this->findAllChildren($parent), ['_self']);
     $responseCollection = collect($transformed)->map(function ($entity) {
         return ['_self' => $entity['_self']];
     })->toArray();
     return $this->getResponse()->collection($responseCollection, ApiResponse::HTTP_CREATED);
 }
 /**
  * Add bookmark
  * route: /bookmarks/add
  * 
  * @param Request $request
  * @return Response
  */
 public function addBookmarkAction(Request $request)
 {
     $data = $request->json()->get('Bookmark');
     $json_return = array();
     if (!isset($data['user_id']) || !isset($data['restaurant_id'])) {
         $message = "Format should be: {'Bookmark': {'user_id': <int>, 'restaurant_id': <int>}}";
         return showErrorResponse($message, HTTP_UNPROCESSABLE_ENTITY);
     }
     $user_id = $data['user_id'];
     $restaurant_id = $data['restaurant_id'];
     if (!Bookmarks::isBookmarked($user_id, $restaurant_id)) {
         try {
             $bookmark = new Bookmarks();
             $bookmark = $bookmark->addBookmark($user_id, $restaurant_id);
             $bookmark[KeyParser::is_bookmarked] = Bookmarks::isBookmarked($user_id, $restaurant_id);
             $bookmark[KeyParser::status] = CONSTANTS::BOOKMARK_SAVED;
             $json_return[KeyParser::data] = ModelFormatter::bookmarkViewFormat($bookmark);
         } catch (\Exception $e) {
             return showErrorResponse('Error adding bookmark');
         }
     } else {
         $bookmark = Bookmarks::getBookmarkByUserIdRestaurantId($user_id, $restaurant_id);
         $bookmark[KeyParser::is_bookmarked] = Bookmarks::isBookmarked($user_id, $restaurant_id);
         $bookmark[KeyParser::status] = CONSTANTS::BOOKMARK_EXISTS;
         $json_return[KeyParser::data] = ModelFormatter::bookmarkViewFormat($bookmark);
     }
     return response()->json($json_return);
 }
 public function update(Request $request, $parent_id, $id)
 {
     $resource = $this->resources->findOrFail($parent_id);
     $related_resource = $this->resources->{$this->relation}()->findOrFail($id);
     $related_resource->fill($request->json()->all());
     $related_resource->save();
     return response()->updated($related_resource);
 }
Exemple #29
0
 public function signin(Request $request)
 {
     $request->request->add(array_merge($request->json()->all(), ['user_type' => 'user']));
     $token = Authorizer::issueAccessToken();
     $guest_token = $request->header('authorization');
     Bag::where('access_token', '=', $guest_token)->update(['access_token' => $token['access_token']]);
     return $token;
 }
 public function update(Request $request, $product_id, $id)
 {
     $product = $this->resources->findOrFail($product_id);
     $photo = $product->photos()->find($id);
     $photo->fill($request->json()->all());
     $photo->save();
     return response()->updated($photo);
 }