/**
* Assign permissions to user
*/
public function updateRoles(Request $request, User $user)
{
$roles = $request->checkedRoles ?: [];
// $roles = array of submitted roles OR if all checkboxes were unchecked, make it an empty array
$user->roles()->sync($roles);
logThis('Roles for ' . $user->name . ' changed to ' . $user->roles()->lists('label'));
return $user->load('roles');
}
public function save(Request $request)
{
$input = $request->all();
// $field_name = implode('|',$input['website']['locales']);
$company = new Company();
$company->name = $input['client']['company_name'];
$company->alias = $input['website']['sub_name'];
$company->save();
$user = new User();
$user->name = $input['client']['name'];
$user->email = $input['client']['email'];
$user->password = $input['client']['password'];
$user->ip = '*';
$user->branch_id = 1;
$user->company_id = $company->id;
$user->active = 1;
$user->save();
$user->roles()->attach(Role::find(1)->id);
// $gr_fields = new GrFields;
// $gr_fields->field_name = $field_name;
// $gr_fields->company_id = $company->id;
// $gr_fields->save();
session(['input' => $input]);
return redirect('thanks');
}
public function store(Request $request)
{
$club = Club::where('_id', $request->get('club_id'))->first();
$team = $club->teams()->where('_id', $request->get('team_id'))->first();
$user = User::where('email', $request->get('email'))->first();
if (empty($user)) {
$user = new User();
$user->first_name = $request->get('first_name');
$user->last_name = $request->get('last_name');
$user->email = $request->get('email');
$user->position = $request->get('position');
$user->active = false;
$user->save();
//team
$role = new Role();
$role->club_id = $club->_id;
$role->club_name = $club->name;
$role->team_id = $team->_id;
$role->team_name = $team->name;
$role->role = 'player';
$user->roles()->save($role);
return response()->json($user, 200);
} else {
return response()->json(array('message' => 'user registered'), 200);
}
}
/**
* Update user
*
* @param UserUpdateRequest $request
* @param $user
* @return \Illuminate\Http\RedirectResponse
*/
public function update(UserUpdateRequest $request, User $user)
{
$user->update($request->only('email', 'password') + ['name' => $request->get('username'), 'email' => $request->get('email')]);
if ($request->has('password')) {
$user->update($request->only('email', 'password') + ['password' => Hash::make($request->get('password'))]);
}
$user->roles()->sync($request->get('roles'));
return redirect()->route('manager.user.index')->with(['message' => 'Сохранен']);
}
public function postCreateUser(Request $request)
{
$user = new User();
$user->login = $request->get("login");
$user->name = $request->get("name");
$user->email = $request->get("email");
$user->password = Hash::make($request->get("password"));
$user->save();
$user->roles()->attach($request->get("role_select"));
return redirect('/personal/user/list');
}
public function register()
{
$user = new User();
$request = Request::all();
$user->name = $request['name'];
$user->email = $request['email'];
$user->password = bcrypt($request['password']);
$user->save();
$user->roles()->attach($request['role_id']);
return redirect('/auth/login');
}
public function viewWeeklyReport()
{
$allowed = ['Admin', 'Project Manager'];
$userRoles = User::roles();
foreach ($userRoles as $role) {
if (in_array($role->role, $allowed)) {
return true;
}
}
return false;
}
public function delete()
{
$allowed = ['Admin'];
$userRoles = User::roles();
foreach ($userRoles as $role) {
if (in_array($role->role, $allowed)) {
return true;
}
}
return false;
}
public function store(Request $request)
{
$user = new User();
$rules = ['name' => 'required', 'email' => 'required|email|unique:users', 'roles_id' => 'array', 'password' => 'required|min:6|confirmed'];
$this->validate($request, $rules);
$user->name = $request->input('name');
$user->email = $request->input('email');
$user->password = bcrypt($request->input('password'));
$user->save();
$user->roles()->sync($request->input('roles_id', []));
return redirect()->route('dashboard.user.index')->with('infos', new MessageBag(["新增用户" . $user['name']]));
}
/**
* Store a newly created resource in storage.
*
* @param \Illuminate\Http\Request $request
* @return \Illuminate\Http\Response
*/
public function store(Request $request)
{
$user = new User();
$request = Request::all();
$role = Role::find($request['user']);
$user->name = $request['name'];
$user->email = $request['email'];
$user->password = bcrypt($request['password']);
$user->save();
$user->roles()->attach($role->id);
return redirect('/admin/users');
}
/**
* Store a newly created resource in storage.
*
* @param Request $request
* @return Response
*/
public function store(Request $request)
{
// TODO: add check if current user is admin before he can add another admin
$a = new User();
if (!$a->validate(Input::all())) {
return redirect('user/create')->withErrors($a->errors())->withInput();
}
$a->fill(Input::all());
$a->save();
$a->roles()->attach(Input::get('role'));
Flash::success('New user is created');
return Redirect::to('user');
}
/**
* Store a newly created user in storage.
*
* @return Response
*/
public function store(Request $request)
{
$users = User::all();
$this->validate($request, ['name' => 'required|max:255', 'email' => 'required|email|max:255|unique:users', 'password' => 'required|min:6|confirmed']);
$user = new User();
$user->name = Input::get('name');
$user->email = Input::get('email');
$user->password = bcrypt(Input::get('password'));
$user->save();
$role = Input::get('roles');
$user->roles()->attach($role);
Session::flash('success', 'User was successful added!');
return redirect('admin/users');
}
public function __construct()
{
$allowed = ['Admin', 'Project Manager'];
$userRoles = User::roles();
$flag = false;
foreach ($userRoles as $role) {
if (in_array($role->role, $allowed)) {
$flag = true;
}
}
if (true != $flag) {
abort(403, 'Now allowed');
}
}
public function store(Request $request, $id = null)
{
if (isset($id)) {
if ($request->input('password')) {
$validator = Validator::make($request->only('username', 'email', 'password', 'password_confirmation'), $this->user->update_rules_with_password);
} else {
$validator = Validator::make($request->only('username', 'email', 'password', 'password_confirmation'), $this->user->update_rules);
}
} else {
$validator = Validator::make($request->only('username', 'email', 'password', 'password_confirmation'), $this->user->create_rules);
}
if ($validator->passes()) {
if (isset($id)) {
$user = $this->user->find($id);
} else {
$user = new User();
}
$user->username = $request->input('username');
$user->email = $request->input('email');
if ($request->input('password')) {
$user->password = Hash::make($request->input('password'));
}
$user->save();
$role = Role::where('role_name', 'admin')->first();
if ($request->input('admin')) {
$user->roles()->attach($role);
} else {
if ($user->hasRole('admin')) {
$user->roles()->detach($role);
}
}
return redirect()->to('users')->with(['success' => 'Saved ' . $user->username]);
} else {
return redirect()->back()->withInput()->withErrors($validator->messages());
}
}
public function update(Request $request, User $user)
{
$user->name = $request->name;
$user->email = $request->email;
$user->password = bcrypt(checkPassword($user->password, $request->password));
$user->save();
if (!$request->input('role_list')) {
$roleList = [];
} else {
$roleList = $request->input('role_list');
}
$user->roles()->sync($roleList);
Flash::success('User Updated!');
return redirect()->action('UserController@index');
}
/**
* Store a newly created resource in storage.
*
* @param \Illuminate\Http\Request $request
* @return \Illuminate\Http\Response
*/
public function store(Request $request)
{
$this->validate($request, ['name' => 'required', 'username' => 'required|unique:users', 'email' => 'required|email|unique:users', 'password' => 'required|min:6|confirmed', 'password_confirmation' => 'same:password', 'role' => 'required|integer|min:1']);
$role = Role::findOrFail($request->role);
$user = new User();
$user->name = strtoupper($request->name);
$user->username = $request->username;
$user->email = $request->email;
$user->password = \Hash::make($request->password);
$user->save();
$user->roles()->attach($role);
Session::flash('flash_message', 'User successfully added.');
Session::flash('flash_class', 'alert-success');
return redirect()->route("store_user.index");
}
/**
* Store a newly created resource in storage.
*
* @return Response
*/
public function store(Request $request)
{
$this->validate($request, ['name' => 'required|max:255', 'email' => 'required|max:255|email|unique:users', 'password' => 'required|min:6']);
$user = new User();
$user->name = $request->get('name');
$user->email = $request->get('email');
$user->password = $request->get('password');
$user->ip = $request->get('ip');
$user->branch_id = intval($request->get('branch_id'));
$user->company_id = Auth::user()->company_id;
$user->active = 0;
$user->save();
$user->roles()->sync($request->get('role'));
flash()->success('User Created Successfully !');
return redirect('user');
}
/**
* Run the database seeds.
*
* @return void
*/
public function run()
{
$role_super_admin = Role::where('name', 'Super Admin')->first();
$role_user = Role::where('name', 'User')->first();
$admin = new User();
$admin->name = 'Shine';
$admin->email = '*****@*****.**';
$admin->password = bcrypt('1Ade$Er32');
$admin->save();
$admin->roles()->attach($role_super_admin);
$user = new User();
$user->name = 'User';
$user->email = '*****@*****.**';
$user->password = bcrypt('ReM1@Et$');
$user->save();
$user->roles()->attach($role_user);
}
/**
* Update the specified user in storage.
*
* @param User $user
* @param UserRequest $request
* @return Response
*/
public function update(User $user, UserRequest $request)
{
$saveRole = function () use($user, $request) {
$user->roles()->sync([$request->get("role")]);
};
$fields = $request->all();
if ($fields['password']) {
$fields['password'] = Hash::make($fields['password']);
} else {
unset($fields['password']);
}
$user->fill($fields);
if ($user->save()) {
call_user_func($saveRole);
Flash::success(trans('admin.update.success'));
} else {
Flash::error(trans('admin.update.fail'));
}
return $this->redirectRoutePath("index");
}
public function doLogin(Request $request)
{
// run the validation rules on the inputs from the form
$validator = Validator::make($request->all(), ['email' => 'required|email', 'password' => 'required|min:3']);
// if the validator fails, redirect back to the form
if ($validator->fails()) {
return redirect('login')->withErrors($validator)->withInput(Input::except('password'));
}
$userdata = ['email' => $request->input('email'), 'password' => $request->input('password')];
if (Auth::attempt($userdata)) {
$allowed = ['Admin', 'Project Manager'];
$userRoles = User::roles();
foreach ($userRoles as $role) {
if (in_array($role->role, $allowed)) {
return redirect()->intended('spa/time-tracker-report');
}
}
return redirect()->intended('home');
}
Session::flash('message', 'There was a problem logging you in. Please check your credentials and try again');
return redirect('/');
}
/**
* Run the migrations.
*
* @return void
*/
public function up()
{
// Inserts the Permissions
Permission::insert($this->permissions);
// Creates a root admin role
$rootadmin = new Role();
$rootadmin->name = "rootadmin";
$rootadmin->display_name = "Root Admin";
$rootadmin->description = "Has Permissions to do everything in the WebPanel";
$rootadmin->save();
//Get all permissions
$ids = Permission::lists('id')->all();
//Sync them to the rootadmin
$rootadmin->perms()->sync($ids);
//Creates an admin user
$admin = new User();
$admin->name = 'admin';
$admin->email = '*****@*****.**';
$admin->password = bcrypt('password');
$admin->save();
$admin->roles()->sync(array($rootadmin->id));
}
private function create_temp_user_and_role_if_not_exists()
{
//Check if the user and group exists
$user = User::where('name', 'temp')->first();
$role = Role::where('name', 'temp')->first();
// Check if user exists, if not create a user
if ($user == null) {
$user = new User();
$user->name = "temp";
$user->email = "*****@*****.**";
$user->password = bcrypt("temp");
$user->save();
}
if ($role == null) {
$role = new Role();
$role->name = "temp";
$role->display_name = "temp";
$role->description = "A Temp Role";
$role->save();
}
$user->roles()->sync(array($role->id));
//Return the existing user and group if they exist
return array($user, $role);
}
/**
* Store a newly created resource in storage.
*
* @param \Illuminate\Http\Request $request
* @return \Illuminate\Http\Response
*/
public function store(UserCreateRequest $request)
{
$persona = new Persona();
$persona->fill($request->all());
$persona->contacto_id = 1;
$persona->fecha_nacimiento = Carbon::createFromTimestamp(strtotime($persona->fecha_nacimiento))->format('Y-m-d');
$persona->save();
$cliente = new Cliente();
$cliente->numero_cliente = 0;
$cliente->curp = '';
$cliente->rfc = '';
$cliente->razon_social = '';
$cliente->actividad_economica = '';
$cliente->fecha_registro = Carbon::now();
$cliente->persona_id = $persona->id;
$cliente->save();
$user = new User();
$user->fill($request->all());
$user->password = bcrypt($request->password);
$user->cliente_id = $cliente->id;
$user->save();
$user->roles()->sync($request->roles);
return redirect()->route('usuario.index');
}
/**
* Sync the Server List
*
* @param User $user
* @param array $roles
*/
private function SyncRoles(User $user, $roles = array())
{
if ($roles == null) {
$roles = array();
}
$user->roles()->sync($roles);
}
/**
* Attach Role to the user
*
* @param \App\User $user
* @return array
*/
protected function addMemberRole(User $user)
{
// 1 is admin, 2 is member
return $user->roles()->sync([2]);
}
/**
* @author WN
* @param User $user
* @param $roles
* @throws Exception
*/
private function applyRoles(User $user, array $roles)
{
if (count($ar = $this->filterSuRole($roles)) > 0) {
$user->merchant_id = null;
if (!$user->save()) {
throw new Exception('Cannot remove Merchant form Super User');
}
$roles = $ar;
}
$user->roles()->sync($roles);
}
/**
* Imports users and creates roles based on addition data in that row.
*
* @return void
*/
public function importInfinityRolesAndBoards()
{
# BORROW SEEDERS
require base_path() . "/database/seeds/OptionSeeder.php";
require base_path() . "/database/seeds/PermissionSeeder.php";
require base_path() . "/database/seeds/RoleSeeder.php";
# DESTROY SEQUENCE
if (DB::connection() instanceof \Illuminate\Database\PostgresConnection) {
$this->comment("\tDropping role sequence.");
DB::statement("DROP SEQUENCE IF EXISTS roles_role_id_seq CASCADE;");
}
$PermissionSeeder = new \PermissionSeeder();
$PermissionSeeder->setCommand($this);
$PermissionSeeder->run();
$PermissionGroupSeeder = new \PermissionGroupSeeder();
$PermissionGroupSeeder->setCommand($this);
$PermissionGroupSeeder->run();
$OptionSeeder = new \OptionSeeder();
$OptionSeeder->setCommand($this);
$OptionSeeder->run();
$OptionGroupSeeder = new \OptionGroupSeeder();
$OptionGroupSeeder->setCommand($this);
$OptionGroupSeeder->run();
$RoleSeeder = new \RoleSeeder();
$RoleSeeder->setCommand($this);
$RoleSeeder->runMaster();
$RolePermissionSeeder = new \RolePermissionSeeder();
$RolePermissionSeeder->setCommand($this);
$RolePermissionSeeder->run();
\Artisan::call('cache:clear');
# REPAIR SEQUENCE
if (DB::connection() instanceof \Illuminate\Database\PostgresConnection) {
$this->comment("\tCreating role_id sequence again.");
DB::statement("CREATE SEQUENCE roles_role_id_seq;");
$pgSeqNext = DB::table('roles')->select(DB::raw("(MAX(\"role_id\") + 1) AS next"))->pluck("next");
DB::statement("ALTER SEQUENCE roles_role_id_seq OWNED BY \"roles\".\"role_id\" RESTART WITH {$pgSeqNext};");
DB::statement("ALTER TABLE roles ALTER COLUMN role_id SET DEFAULT nextval('roles_role_id_seq');");
}
# THEIR TABLES
$tBoardsTable = $this->tcon->table("boards")->join('board_create', 'boards.uri', '=', 'board_create.uri')->select('boards.*', 'board_create.time');
$tModsTable = $this->tcon->table("mods");
# BEGIN USER IMPORT
$this->info("\tImporting Users ...");
$userAdmin = null;
$userBoardRelationships = [];
$usersImported = 0;
$tModsTable->chunk(100, function ($mods) use(&$userAdmin, &$userBoardRelationships, &$usersImported) {
$this->line("\t\tHandling 100 users ...");
foreach ($mods as $mod) {
# CREATE USER
$user = new User(['username' => $mod->username, 'email' => property_exists($mod, "email") ? $mod->email ?: null : null, 'password' => null, 'password_legacy' => json_encode(['hasher' => "Vichan", 'hash' => $mod->password, 'salt' => $mod->salt])]);
// 8chan has an issue with duplicates.
try {
$saved = $user->save();
} catch (\Exception $e) {
$saved = false;
}
if ($saved) {
++$usersImported;
# REMEMBER ROLES
if ($mod->boards) {
// TODO
// Pull these values from config when formal importer created.
switch ($mod->type) {
// Janitor (Disabled)
case 10:
// Disabled
// Disabled
case 99:
$this->comment("\t\tMod {$user->username} is disabled.");
break;
// Board volunteer
// Board volunteer
case 19:
// Board owner
// Board owner
case 20:
if (!isset($userBoardRelationships[$mod->boards])) {
$userBoardRelationships[$mod->boards] = [];
}
$userBoardRelationships[$mod->boards][$user->user_id] = $mod->type;
break;
// Global volunteer
// Global volunteer
case 25:
$this->comment("\t\tSetting {$user->username} to Global Mod.");
$user->roles()->attach(Role::ID_MODERATOR);
break;
// Admin
// Admin
case 30:
$this->comment("\t\tSetting {$user->username} to Global Admin.");
$user->roles()->attach(Role::ID_ADMIN);
$userAdmin = $userAdmin ?: $user;
break;
// Not identified!
// Not identified!
default:
$this->error("\t\tMod {$user->username} has invalid mod type {$mod->type}.");
break;
}
}
}
}
});
$this->info("\tImported {$usersImported} users(s).");
if (!$userAdmin) {
$this->comment("\tFailed to import an admin. This may cause problems.");
}
unset($mods, $mod, $user);
# BEGIN BOARD IMPORT
$this->info("\tImporting Boards ...");
$boardsImported = 0;
$tBoardsTable->chunk(100, function ($boards) use(&$boardsImported, $userAdmin, $userBoardRelationships) {
$this->line("\t\tHandling 100 boards ...");
foreach ($boards as $tBoard) {
// We have an array like [board_uri => [ user_id => user_role ]] in the user import.
// This fetches the first key of the biggest item.
$boardOwner = [];
if (isset($userBoardRelationships[$tBoard->uri])) {
$boardOwner = array_keys($userBoardRelationships[$tBoard->uri], max($userBoardRelationships[$tBoard->uri]));
}
// Or it defaults to our admin.
if (!isset($boardOwner[0])) {
$this->comment("\t\t/{$tBoard->uri}/ has no known owner, assuming it is {$userAdmin->username}.");
$boardOwner = $userAdmin->user_id;
} else {
$boardOwner = isset($boardOwner) ? $boardOwner[0] : $userAdmin->user_id;
}
$hBoard = new Board(['board_uri' => $tBoard->uri, 'title' => $tBoard->title, 'description' => $tBoard->subtitle, 'created_at' => new Carbon($tBoard->time), 'created_by' => $boardOwner, 'operated_by' => $boardOwner, 'posts_total' => $tBoard->posts_total, 'is_indexed' => !!$tBoard->indexed, 'is_overboard' => !!$tBoard->indexed, 'is_worksafe' => !!$tBoard->sfw]);
if ($hBoard->save()) {
++$boardsImported;
if (!$tBoard->public_bans || !$tBoard->public_logs || $tBoard->public_logs == 2) {
$role = Role::getAnonymousRoleForBoard($hBoard);
$perms = [];
if (!$tBoard->public_bans) {
$perms[] = ['permission_id' => "board.bans", 'value' => false];
}
if (!$tBoard->public_logs || $tBoard->public_logs == 2) {
$perms[] = ['permission_id' => "board.logs", 'value' => false];
}
$role->permissionAssignments()->createMany($perms);
}
} else {
$this->error("Failed to save /{$hBoard->board_uri}/.");
}
}
});
$this->info("\tImported {$boardsImported} board(s).");
unset($boards, $tBoard, $hBoard);
# BEGIN ROLE CONFIGURATION
$this->info("\tCreating roles ...");
$roleBoardVols = 0;
$roleBoardOwners = 0;
$roleBoardSkips = 0;
// Okay, so apparently sometimes there are users that own boards that don't exist.
// We cannot crate roles for these boards, so lets prune useless data.
$boardsWeCareAbout = Board::select('board_uri')->whereIn('board_uri', array_keys($userBoardRelationships))->get()->pluck('board_uri');
if ($boardsWeCareAbout->count() != count($userBoardRelationships)) {
$this->comment("\t\tThere are " . (count($userBoardRelationships) - $boardsWeCareAbout->count()) . " board(s) which users own that do not exist!");
}
foreach ($boardsWeCareAbout as $board) {
$ownerRole = null;
$janitorRole = null;
$roles = $userBoardRelationships[$board];
foreach ($roles as $mod => $role) {
// TODO
// Pull these values from config when formal importer created.
switch ($role) {
// Board volunteer
case 19:
$janitorRole = $janitorRole ?: Role::getJanitorRoleForBoard($board);
$userRole = new UserRole(['user_id' => $mod, 'role_id' => $janitorRole->role_id]);
if ($userRole->save()) {
++$roleBoardVols;
}
break;
// Board owner
// Board owner
case 20:
$ownerRole = $ownerRole ?: Role::getOwnerRoleForBoard($board);
$userRole = new UserRole(['user_id' => $mod, 'role_id' => $ownerRole->role_id]);
if ($userRole->save()) {
++$roleBoardOwners;
}
break;
default:
$this->line("\t\tI don't know what to do with role {$role} for user id {$mod} in {$board}.");
break;
}
}
}
$this->info("\t\tCreated {$roleBoardOwners} owner(s) and {$roleBoardVols} janitor(s) ");
$this->info("\t\tPulled roles from " . count($userBoardRelationships) . " boards with relationships.");
unset($board, $roles, $mod, $role, $userRole, $janitorRole, $ownerRole);
}
/**
* User update form processing page.
*
* @param User $user
* @param UserRequest $request
* @return Redirect
*/
public function update(User $user, UserRequest $request)
{
try {
$user->first_name = $request->get('first_name');
$user->last_name = $request->get('last_name');
$user->email = $request->get('email');
$user->dob = $request->get('dob');
$user->bio = $request->get('bio');
$user->gender = $request->get('gender');
$user->country = $request->get('country');
$user->state = $request->get('state');
$user->city = $request->get('city');
$user->address = $request->get('address');
$user->postal = $request->get('postal');
if ($password = $request->has('password')) {
$user->password = Hash::make($password);
}
// is new image uploaded?
if ($file = $request->file('pic')) {
$extension = $file->getClientOriginalExtension() ?: 'png';
$folderName = '/uploads/users/';
$destinationPath = public_path() . $folderName;
$safeName = str_random(10) . '.' . $extension;
$file->move($destinationPath, $safeName);
//delete old pic if exists
if (File::exists(public_path() . $folderName . $user->pic)) {
File::delete(public_path() . $folderName . $user->pic);
}
//save new file path into db
$user->pic = $safeName;
}
//save record
$user->save();
// Get the current user groups
$userRoles = $user->roles()->lists('id')->all();
// Get the selected groups
$selectedRoles = $request->get('groups', array());
// Groups comparison between the groups the user currently
// have and the groups the user wish to have.
$rolesToAdd = array_diff($selectedRoles, $userRoles);
$rolesToRemove = array_diff($userRoles, $selectedRoles);
// Assign the user to groups
foreach ($rolesToAdd as $roleId) {
$role = Sentinel::findRoleById($roleId);
$role->users()->attach($user);
}
// Remove the user from groups
foreach ($rolesToRemove as $roleId) {
$role = Sentinel::findRoleById($roleId);
$role->users()->detach($user);
}
// Activate / De-activate user
$status = $activation = Activation::completed($user);
if ($request->get('activate') != $status) {
if ($request->get('activate')) {
$activation = Activation::exists($user);
if ($activation) {
Activation::complete($user, $activation->code);
}
} else {
//remove existing activation record
Activation::remove($user);
//add new record
Activation::create($user);
//send activation mail
$data = array('user' => $user, 'activationUrl' => URL::route('activate', $user->id, Activation::exists($user)->code));
// Send the activation code through email
Mail::send('emails.register-activate', $data, function ($m) use($user) {
$m->to($user->email, $user->first_name . ' ' . $user->last_name);
$m->subject('Welcome ' . $user->first_name);
});
}
}
// Was the user updated?
if ($user->save()) {
// Prepare the success message
$success = Lang::get('users/message.success.update');
// Redirect to the user page
return Redirect::route('admin.users.edit', $user)->with('success', $success);
}
// Prepare the error message
$error = Lang::get('users/message.error.update');
} catch (UserNotFoundException $e) {
// Prepare the error message
$error = Lang::get('users/message.user_not_found', compact('user'));
// Redirect to the user management page
return Redirect::route('users')->with('error', $error);
}
// Redirect to the user page
return Redirect::route('admin.users.edit', $user)->withInput()->with('error', $error);
}
/**
* Initialize the user group
*
*/
public function setupFounderAndBaseRolesPermission()
{
//Create Roles
$founder = new Role();
$founder->name = 'Founder';
$founder->save();
$admin = new Role();
$admin->name = 'Admin';
$admin->save();
//Create User
$user = new User();
$user->name = 'muzhuang';
$user->email = '*****@*****.**';
$user->password = Hash::make('secret');
if (!$user->save()) {
Log::info('Unabel to create user ' . $user->username, (array) $user->errors());
} else {
Log::info('Create user "' . $user->username . '" <' . $user->email . '>');
}
//Attach Roles to user
$user->roles()->attach($founder->id);
//Create Permissions
$manageUsers = new Permission();
$manageUsers->name = 'admin.user';
$manageUsers->display_name = 'Manage Users';
$manageUsers->save();
// Assign Permission to Role
$founder->perms()->sync([$manageUsers->id]);
$admin->perms()->sync([$manageUsers->id]);
}
/**
* Show and edit selected user.
*
* @param \App\User $user
* @return \Illuminate\View\View
*/
public function edit(User $user)
{
$roles = $this->getAllowedRoles();
$selectedRoles = $user->roles()->pluck('roles.id')->toArray();
return view('administrator.users.edit', compact('user', 'roles', 'selectedRoles'));
}