PHP Member::findOrFail方法代码示例

 public function getDeleteEquipe($id)
 {
     $membro = Member::findOrFail($id);
     $membro->delete();
     $equipe = Member::all()->sortBy("name");
     return redirect('/editar_equipe')->with('equipe', $equipe);
 }

 public function update(Request $request, $id)
 {
     $member = \App\Member::findOrFail($id);
     $member->name = $request->name;
     $member->save();
     return redirect('/');
 }

 /**
  * Obtain the user information from GitHub.
  *
  * @return Response
  */
 public function handleProviderCallback(Request $request)
 {
     // Used for development purposes. Hit /auth/google/callback
     // to get a dummy JWT for local use.
     if (\App::environment('local')) {
         $member = Member::findOrFail(1);
         if (!$member->hasRole('member')) {
             $member->attachRole(Role::where('name', 'member')->firstOrFail());
         }
         $token = JWTAuth::fromUser($member, ['level' => config('auth.levels.high'), 'member' => $member]);
         return response()->json($token);
     }
     $provider = new GoogleRitProvider($request);
     $user = $provider->user();
     if (array_get($user->user, 'domain', '') != 'g.rit.edu') {
         return new JsonResponse(['error' => 'domain user not authorized'], Response::HTTP_FORBIDDEN);
     }
     $member = Member::firstOrNew(['email' => $user->email]);
     $member->first_name = $user->user['name']['givenName'];
     $member->last_name = $user->user['name']['familyName'];
     $member->save();
     if (!$member->hasRole('member')) {
         $member->attachRole(Role::where('name', 'member')->firstOrFail());
     }
     $token = JWTAuth::fromUser($member, ['level' => config('auth.levels.high'), 'member' => $member]);
     if ($callback = $provider->getCallback()) {
         return redirect($callback . '?token=' . $token);
     } else {
         return response()->json(['token' => $token]);
     }
 }

 public function byId($id)
 {
     try {
         $this->member = Member::findOrFail($id);
         return true;
     } catch (ModelNotFoundException $e) {
         return false;
     }
 }

 /**
  * Update the specified resource in storage.
  *
  * @param  Request  $request
  * @param  int  $id
  * @return Response
  */
 public function update(Request $request, $id)
 {
     $member = Member::findOrFail($id);
     // TODO handle exception
     $member->first_name = $request->input('first_name', $member->first_name);
     $member->last_name = $request->input('last_name', $member->last_name);
     $member->save();
     return response()->json($member);
 }

 /**
  * Run the database seeds.
  *
  * @return void
  */
 public function run()
 {
     $admin = Role::firstOrCreate(['name' => 'admin', 'display_name' => 'Administrator', 'description' => 'Member is an administrator']);
     $member = Role::firstOrCreate(['name' => 'member', 'display_name' => 'Member', 'description' => 'Generic membership role']);
     $mentor = Role::firstOrCreate(['name' => 'mentor', 'display_name' => 'Mentor', 'description' => 'Member is a mentor']);
     $officer = Role::firstOrCreate(['name' => 'officer', 'display_name' => 'Officer', 'description' => 'Member is an officer']);
     if (\App::environment('local')) {
         $member = Member::findOrFail(1);
         $member->attachRole($admin);
     }
 }

 /**
  * Store a newly created resource in storage.
  *
  * @Response(201)
  * @param  Request  $request
  * @return Response
  */
 public function store(Request $request)
 {
     $this->validate($request, ['member_id' => 'required|exists:members,id', 'reason' => 'required', 'term_id' => 'required|exists:terms,id']);
     $member = Member::findOrFail($request->input('member_id'));
     $term = Term::findOrFail($request->input('term_id'));
     $membership = new Membership();
     $membership->reason = $request->input('reason');
     $membership->term_id = $request->input('term_id');
     $member->memberships()->save($membership);
     return new JsonResponse($membership, Response::HTTP_CREATED);
 }

 /**
  * Update the specified resource in storage.
  *
  * @param  Request  $request
  * @param  int  $id
  * @return Response
  */
 public function update(Request $request, $id)
 {
     $this->validate($request, ['first_name' => 'string', 'last_name' => 'string']);
     try {
         $member = Member::findOrFail($id);
         $member->first_name = $request->input('first_name', $member->first_name);
         $member->last_name = $request->input('last_name', $member->last_name);
         $member->save();
         return response()->json($member);
     } catch (ModelNotFoundException $e) {
         return new JsonResponse(['error' => 'not found'], Response::HTTP_NOT_FOUND);
     }
 }

 public function store(Request $request, $memberId)
 {
     // Upload a chunk, then
     // check if all chunks are done. If so
     // save the chunk to the database
     $config = new \Flow\Config();
     $config->setTempDir($this->tmpDir);
     $file = new \Flow\FileReadable($config);
     if ($file->validateChunk()) {
         $file->saveChunk();
     } else {
         // error, invalid chunk upload request, retry
         return response('', Response::HTTP_BAD_REQUEST);
         // 400
     }
     // Check for completion
     if ($file->validateFile()) {
         $blob = $file->saveToStream();
         $mimeType = $this->parseImageMimeType(strrchr($file->name(), '.'));
         if (!$mimeType) {
             // Not going to save if we don't know the mime type
             return response('Cannot determine image mime type from filename: ' . $file->name(), Response::HTTP_UNSUPPORTED_MEDIA_TYPE);
             // 415
         }
         // // If we wanted to ensure a 1-to-1 mapping for Member record and MemberPicture
         // MemberPicture::updateOrCreate(['regt_num' => $memberId], [
         // 'photo_blob' => $blob,
         // 'file_size' => $file->size(),
         // 'mime_type' => $mimeType
         // ]);
         $mp = new MemberPicture();
         // $mp->regt_num = $memberId;
         $mp->photo_blob = $blob;
         $mp->file_name = $file->name();
         $mp->file_size = $file->size();
         $mp->mime_type = $mimeType;
         $member = Member::findOrFail($memberId);
         $member->pictures()->save($mp);
         return response('Upload OK', Response::HTTP_CREATED);
         // 201
     }
     return response('', Response::HTTP_ACCEPTED);
     // 202
 }

 /**
  * Remove the specified resource from storage.
  * Defaults to a soft delete; add ?remove=permanent to do hard delete
  *
  * @param  int  $id
  * @return Response
  */
 public function destroy(Request $request, $id)
 {
     // remove -- [ discharge | permanent ]
     $removeMode = $request->query('remove', 'discharge');
     $deleted = 0;
     try {
         if ($removeMode == 'permanent') {
             $deletionMember = Member::where('regt_num', $id)->withTrashed()->firstOrFail();
             // Todo: future permissions check
             $permissionsCheck = true;
             if ($permissionsCheck || $deletionMember->is_active == '0') {
                 // Allow anybody to delete inactive records
                 $deletionMember->postings()->forceDelete();
                 $deletionMember->forceDelete();
                 // this returns void
                 $deleted = true;
                 // we just presume it worked, since we deleted the postings already
             } else {
                 throw new \Exception('You don\'t have permission to permanently delete this record', ResponseCodes::ERR_PERM_NOPE);
             }
         } else {
             // Soft delete -- read overrides from context
             $deleted = Member::findOrFail($id)->delete();
         }
         return response()->json(['success' => $deleted, 'deletionMode' => $removeMode]);
     } catch (\Exception $ex) {
         if (!$deleted) {
             return response()->json(['error' => ['code' => ResponseCodes::ERR_DELETION, 'deletionResult' => print_r($deleted, true), 'reason' => "Could not delete this record {$id}"]], 401);
         } else {
             return response()->json(['error' => ['code' => $ex->getCode(), 'reason' => $ex->getMessage()]], 403);
         }
     }
 }

 /**
  * Get new order of members from post data and save it to database
  *
  * @return mixed
  */
 public function changeOrder()
 {
     // Get id/order pairs
     $newOrders = Input::get('data');
     // Change each member's order to the new one
     foreach ($newOrders as $newOrder) {
         $member = Member::findOrFail($newOrder['id']);
         $member->order = $newOrder['order'];
         $member->save();
     }
     // Return success json
     return Response::json('success', 200);
 }

 /**
  * Upload the user's CV
  *
  * @param  Request  $request
  * @param  int  $id
  * @return Response
  */
 public function uploadCV(Request $request, $id)
 {
     $member = Member::findOrFail($id);
     if (Gate::denies('upload-cv', $member)) {
         abort(403);
     }
     $this->validate($request, ['cv' => 'required|mimes:pdf']);
     // Handle cv PDF
     if ($request->file('cv')->isValid()) {
         $request->file('cv')->move(storage_path('app/cvs'), $id . '.pdf');
         return response()->json("ok");
     } else {
         abort(400);
     }
 }