/**
* Execute the job.
*
* @return bool
*/
public function handle()
{
// Don't allow changing the name of the administrator account.
if (!$this->role->isAdministrator()) {
$this->role->name = $this->request->input('name', $this->role->name);
}
$this->role->label = $this->request->input('label', $this->role->label);
return $this->role->save();
}
public function save(Request $request)
{
$as = $request->input('as');
$role = new Role();
$validator = \Validator::make($request->all(), $role->getRules());
$results = new \StdClass();
if ($validator->passes()) {
if ($request->input('id') != 'xxx') {
$role = Role::find($request->input('id'));
$role->name = $request->input('name');
$role->display_name = $request->input('displayname');
$role->description = $request->input('description');
$role->save();
$results->info = 'role create';
} else {
$role = new Role();
$role->name = $request->input('name');
$role->display_name = $request->input('displayname');
$role->description = $request->input('description');
$role->save();
$results->info = 'role edit';
}
$results->status = 1;
$results->result = $role;
} else {
$results->status = 0;
$result = array();
foreach ($validator->errors() as $key => $err) {
array_push($result, $err);
}
$results->result = $result;
}
return response()->json($results);
}
/**
* @param $input
* @throws GeneralException
* @return bool
*/
public function create($input)
{
if (Role::where('role_name', $input['role_name'])->first()) {
throw new GeneralException('That role already exists. Please choose a different name.');
}
if (count($input['assignees_permissions']) == 0) {
throw new GeneralException('You must select at least one permission for this role.');
}
$role = new Role();
$role->role_name = $input['role_name'];
$role->role_slug = $input['role_slug'];
$role->role_description = $input['role_description'];
if ($role->save()) {
$current = $input['assignees_permissions'];
$permissions = [];
if (count($current)) {
foreach ($current as $perm) {
if (is_numeric($perm)) {
array_push($permissions, $perm);
}
}
}
$role->attachPermissions($permissions);
return true;
}
throw new GeneralException('There was a problem creating this role. Please try again.');
}
/**
* Run the database seeds.
*
* @return void
*/
public function run()
{
$user_1 = new User();
$user_1->name = 'tech';
$user_1->email = '*****@*****.**';
$user_1->password = \Hash::make('tech1234');
$user_1->phone = '082214250262';
$user_1->jabatan = 'Technical Administrator';
$user_1->save();
$user_2 = new User();
$user_2->name = 'admin';
$user_2->email = '*****@*****.**';
$user_2->password = \Hash::make('admin1234');
$user_2->phone = '082214250262';
$user_2->jabatan = 'Management Administrator';
$user_2->save();
$role_1 = new Role();
$role_1->name = 'tech';
$role_1->display_name = 'tech';
$role_1->description = 'Technical Administration';
$role_1->save();
$role_2 = new Role();
$role_2->name = 'admin';
$role_2->display_name = 'admin';
$role_2->description = 'Management Administration';
$role_2->save();
$user_1->attachRole($role_1);
$user_2->attachRole($role_2);
}
public function run()
{
$adminEmail = Config::get('madison.seeder.admin_email');
$admin = new Role();
$admin->name = 'Admin';
$admin->save();
$independent_sponsor = new Role();
$independent_sponsor->name = 'Independent Sponsor';
$independent_sponsor->save();
$permIds = array();
foreach ($this->adminPermissions as $permClass => $data) {
$perm = new Permission();
foreach ($data as $key => $val) {
$perm->{$key} = $val;
}
$perm->save();
$permIds[] = $perm->id;
}
$admin->perms()->sync($permIds);
$user = User::where('email', '=', $adminEmail)->first();
$user->attachRole($admin);
$createDocPerm = new Permission();
$createDocPerm->name = "independent_sponsor_create_doc";
$createDocPerm->display_name = "Independent Sponsoring";
$createDocPerm->save();
$independent_sponsor->perms()->sync(array($createDocPerm->id));
}
public function run()
{
DB::table('roles')->truncate();
DB::table('role_user')->truncate();
DB::table('permissions')->truncate();
DB::table('permission_role')->truncate();
$admin_role = new Role();
$admin_role->name = 'admin';
$admin_role->display_name = 'Administrator';
$admin_role->description = 'manages everything';
$admin_role->save();
$reviewer_role = new Role();
$reviewer_role->name = 'reviewer';
$reviewer_role->display_name = 'Reviewer';
$reviewer_role->description = 'reviews inserted data';
$reviewer_role->save();
$inserter_role = new Role();
$inserter_role->name = 'inserter';
$inserter_role->display_name = 'Inserter';
$inserter_role->description = 'inserts data about billboards';
$inserter_role->save();
$admin = User::find(1);
$reviewer = User::find(2);
$inserters = User::whereNotIn('id', [$admin->id, $reviewer->id])->get();
$admin->attachRole($admin_role);
$reviewer->attachRole($reviewer_role);
foreach ($inserters as $user) {
$user->attachRole($inserter_role);
}
}
/**
* Run the database seeds.
*
* @return void
*/
public function run()
{
$role = new Role();
$role->name = 'Admin';
$role->slug = str_slug('admin');
$role->save();
}
public function CreaRoles()
{
$alumno = new Role();
$alumno->name = 'alumno';
$alumno->display_name = 'Usuario Alumno';
// optional
$alumno->description = 'Usuario Alumno puede entrar y reservar';
// optional
$alumno->save();
$coach = new Role();
$coach->name = 'coach';
$coach->display_name = 'Coach';
// optional
$coach->description = 'Coach del Box';
// optional
$coach->save();
$admin = new Role();
$admin->name = 'admin';
$admin->display_name = 'Usuario Administrator';
// optional
$admin->description = 'Tiene todos los permisos';
// optional
$admin->save();
$recepcion = new Role();
$recepcion->name = 'recepcion';
$recepcion->display_name = 'Usuario Recepción';
// optional
$recepcion->description = 'User is allowed to manage and edit other users';
// optional
$recepcion->save();
}
public function setupFoundorAndBaseRolsPermission()
{
// Create Roles
$founder = new Role();
$founder->name = 'Founder';
$founder->save();
$admin = new Role();
$admin->name = 'Admin';
$admin->save();
// Create User
$user = new User();
$user->username = '******';
$user->display_name = 'Admin';
$user->email = '*****@*****.**';
$user->password = '******';
if (!$user->save()) {
Log::info('Unable to create user ' . $user->username, (array) $user->errors());
} else {
Log::info('Created user "' . $user->username . '" <' . $user->email . '>');
}
// Attach Roles to user
$user->roles()->attach($founder->id);
// Create Permissions
$manageContent = new Permission();
$manageContent->name = 'manage_contents';
$manageContent->display_name = 'Manage Content';
$manageContent->save();
$manageUsers = new Permission();
$manageUsers->name = 'manage_users';
$manageUsers->display_name = 'Manage Users';
$manageUsers->save();
// Assign Permission to Role
$founder->perms()->sync([$manageContent->id, $manageUsers->id]);
$admin->perms()->sync([$manageContent->id]);
}
/**
* Store a newly created resource in storage.
*
* @return Response
*/
public function store()
{
$rules = ['name' => 'required|alpha_dash|min:1|max:255', 'display_name' => 'string|max:255', 'description' => 'string', 'permissions' => 'array|integerInArray|existsInArray:permission,id'];
$validator = Validator::make(Input::only(array_keys($rules)), $rules);
if ($validator->fails()) {
throw new ResourceException($validator->errors()->first());
}
$role = new Role();
$fields = ['name'];
foreach ($fields as $key => $field) {
if (Input::has($field)) {
$role->{$field} = Input::get($field);
}
}
//field which can null/empty string
$fields = ['description', 'display_name'];
foreach ($fields as $key => $field) {
if (Input::get($field) === '') {
$role->{$field} = null;
} elseif (Input::has($field)) {
$role->{$field} = Input::get($field);
}
}
$role->save();
$role->perms()->sync(Input::get('permissions', []));
return $this->show($role->id);
}
/**
* Run the database seeds.
*
* @return void
*/
public function run()
{
$adminRole = new Role();
$adminRole->name = 'admin';
$adminRole->display_name = 'Admin';
$adminRole->description = 'Admin for backend';
$adminRole->is_admin = 1;
$adminRole->save();
$userRole = new Role();
$userRole->name = 'user';
$userRole->display_name = 'User';
$userRole->description = 'user for backend';
$userRole->is_admin = 0;
$userRole->save();
$admin = User::where('email', '*****@*****.**')->first();
$assRoleAdmin = new AssignedRole();
$assRoleAdmin->user_id = $admin->id;
$assRoleAdmin->role_id = $adminRole->id;
$assRoleAdmin->save();
$user = User::where('email', '*****@*****.**')->first();
$assRoleUser = new AssignedRole();
$assRoleUser->user_id = $user->id;
$assRoleUser->role_id = $userRole->id;
$assRoleAdmin->save();
}
/**
* Store role
*
* @param array $roleData
* @throws NotFoundException, ValidationException
* @return \App\Models\RoleModel
*/
public function store($roleData)
{
try {
if (array_get($roleData, 'id')) {
$role = RoleModel::findOrFail((int) array_get($roleData, 'id'))->fill($roleData);
} else {
$role = new RoleModel();
$role->fill($roleData);
}
} catch (Exception $e) {
throw new NotFoundException(trans('app.notFound'));
}
if (!$role->validate()) {
throw new ValidationException(trans('app.correctErrors'), $role->errors()->toArray());
}
try {
$role->save();
// associate permissions
if (array_get($roleData, 'permission_id')) {
$role->perms()->sync(array_get($roleData, 'permission_id'));
}
} catch (Exception $e) {
throw $e;
}
return $role;
}
public function setupRolesPermissions()
{
$master = User::findOrFail(1);
if ($master) {
// Create role
$owner = new Role();
$owner->name = 'master';
$owner->display_name = 'Project Owner';
$owner->description = 'The Master of Universe';
$owner->save();
// Create permissions
$createUser = new Permission();
$createUser->name = 'user-create';
$createUser->display_name = 'Create Users';
$createUser->description = 'Create new users';
$createUser->save();
$editUser = new Permission();
$editUser->name = 'user-edit';
$editUser->display_name = 'Edit Users';
$editUser->description = 'Edit existing users';
$editUser->save();
$deleteUser = new Permission();
$deleteUser->name = 'user-delete';
$deleteUser->display_name = 'Delete Users';
$deleteUser->description = 'Delete existing users';
$deleteUser->save();
// Attach permissions
$owner->attachPermissions([$createUser, $editUser, $deleteUser]);
// Attach roles
$master->attachRole($owner);
// using facade
}
return redirect()->route('access.test');
}
public function run()
{
$roles = ['admin', 'user'];
foreach ($roles as $role) {
$instance = new Role(['role' => $role]);
$instance->save();
}
}
public function store(Request $request)
{
$role = new Role();
$role->name = $request->name;
$role->label = $request->label;
$role->save();
return redirect()->action('Admin\\RolesController@index');
}
public function store($name)
{
// create new instance
$role = new Role();
$role->name = $name;
// persist
$role->save();
return $role;
}
/**
* Store a newly created resource in storage.
*
* @return Response
*/
public function store(RoleRequest $request)
{
$role = new Role();
$role->name = $request->name;
$role->description = $request->description;
$role->save();
$url = session('SOURCE_URL');
return redirect()->to($url)->with('message', trans('terms.record-successfully-saved'))->with('active_role', $role->id);
}
/**
* Creates a new Role model.
* If creation is successful, the browser will be redirected to the 'view' page.
* @return mixed
*/
public function actionCreate()
{
$model = new Role();
if ($model->load(Yii::$app->request->post()) && $model->save()) {
return $this->redirect(['view', 'id' => $model->id]);
} else {
return $this->render('create', ['model' => $model]);
}
}
public function run()
{
DB::table('roles')->delete();
$adminRole = new Role();
$adminRole->name = 'admin';
$adminRole->save();
$user = User::where('name', '=', 'admin')->first();
$user->attachRole($adminRole);
}
public function addRoles()
{
$name = \Input::get('name');
$role = new Role();
$role->name = $name;
$data['status'] = $role->save() ? 200 : 500;
$data['role'] = $role->id;
$data['created_at'] = $role->created_at;
return \Response::json($data);
}
/**
* @param array $data
* @return bool
*/
public function execute(array $data)
{
if (!$this->isValid($data)) {
return false;
}
$role = new Role();
$role->name = $data['name'];
$role->slug = str_slug($data['name']);
return $role->save();
}
public function completeRegistration($params = array())
{
$user = $this->api->user();
$defaults = array('verification_code' => $verification_code = null, 'app_subdomain' => $app_subdomain = null, 'email_domains' => $email_domains = null, 'name' => $name = null);
$this->api->validation_factory->extend('email_domains', function ($attribute, $value, $parameters) {
$email_domains = $this->toArray($value);
foreach ($email_domains as $domain) {
if (!filter_var('fakeemail@' . $domain, FILTER_VALIDATE_EMAIL)) {
return false;
}
}
return true;
});
$rules = array('verification_code' => array('required', 'exists:organizations,verification_code,registration_complete,0'), 'app_subdomain' => array('required', 'alpha_dash', 'unique:organizations'), 'email_domains' => array('sometimes', 'email_domains'));
$messages = array('app_subdomain.alpha_dash' => 'Please enter a valid subdomain', 'app_subdomain.unique' => 'The requested subdomain is not available', 'email_domains.email_domains' => 'Please enter valid email domains');
$params = $this->validateParams($defaults, $params, $rules, $messages);
extract($params);
/**
* @var Organization
*/
$organization = $this->query()->where('verification_code', $verification_code)->where('registration_complete', false)->first();
$organization->app_subdomain = $app_subdomain;
if (!empty($name)) {
$organization->name = $name;
}
/**
* It's possible that during the time when the above unique subdomain validation
* is run and the time the organization is saved, that someone else claimed the subdomain.
* In that case, the save() query will fail, so we wrap it in a try/catch.
*/
try {
$organization->save();
$email_domains = $this->toArray($email_domains);
if (!empty($email_domains)) {
$saved_email_domains = array();
foreach ($email_domains as $email_domain) {
$saved_email_domains[] = new EmailDomain(array('domain' => trim($email_domain)));
}
$organization->emailDomains()->saveMany($saved_email_domains);
}
$admin = new Role();
$admin->name = $organization->roleAdminName();
$admin->display_name = $organization->roleAdminDisplayName();
$admin->save();
$user->attachRole($admin);
$organization->registration_complete = true;
$organization->save();
$this->entity = $organization;
$this->api->event->fire(new OrganizationRegistrationCompleted($organization));
return $this->entity();
} catch (QueryException $e) {
throw new BadRequestException('The requested subdomain is not available');
}
}
public function run()
{
$items = [["Assistant", "C'est un assistant. Il fait des trucs d'assistant."], ["Soigneur", "Un soigneur guéri un athlète à l'aide de sa magie blanche."], ["Accompagnateur", "Un accompagnateur accompagne un athlète pour qu'il ne soit pas seul."]];
DB::table('roles')->delete();
foreach ($items as $item) {
$role = new Role();
$role->nom = $item[0];
$role->description = $item[1];
$role->save();
}
}
public static function addRole($name, $label = null, $description = null)
{
$role = Role::query()->where('name', $name)->first();
if (!$role) {
$role = new Role(['name' => $name]);
}
$role->label = $label;
$role->description = $description;
$role->save();
return $role;
}
/**
* Creates a new Role model.
* If creation is successful, the browser will be redirected to the 'view' page.
* @return mixed
*/
public function actionCreate()
{
$model = new Role();
try {
if ($model->load($_POST) && $model->save()) {
return $this->redirect(Url::previous());
} elseif (!\Yii::$app->request->isPost) {
$model->load($_GET);
}
} catch (\Exception $e) {
$msg = isset($e->errorInfo[2]) ? $e->errorInfo[2] : $e->getMessage();
$model->addError('_exception', $msg);
}
return $this->render('create', ['model' => $model]);
}
/**
* Enregistre dans la bd la ressource qui vient d'être créée.
*
* @return Response
*/
public function store()
{
try {
$input = Input::all();
$role = new Role();
$role->nom = $input['nom'];
$role->description = $input['description'];
} catch (ModelNotFoundException $e) {
App::abort(404);
}
if ($role->save()) {
return Redirect::action('RolesController@index');
} else {
return Redirect::back()->withInput()->withErrors($role->validationMessages());
}
}
function _createRoles()
{
$user = new Role();
$user->name = 'user';
$user->display_name = 'User';
// optional
$user->description = 'User is the owner of a given campaign';
// optional
$user->save();
$admin = new Role();
$admin->name = 'admin';
$admin->display_name = 'User Administator';
// optional
$admin->description = 'User is allowed to manage and edit other users';
// optional
$admin->save();
}
public function run()
{
DB::table('users')->delete();
DB::table('roles')->delete();
DB::table('permissions')->delete();
DB::table('permission_role')->delete();
//Create user roles
$user = new Role();
$user->name = 'user';
$user->display_name = 'Project User';
$user->description = 'Just User';
$user->save();
$admin = new Role();
$admin->name = 'admin';
$admin->display_name = 'User Administrator';
$admin->description = 'User is allowed to manage and edit other users';
$admin->save();
DB::table('users')->insert(['name' => 'admin', 'email' => '*****@*****.**', 'password' => bcrypt('12345678')]);
$user = User::where('email', '=', '*****@*****.**')->first();
$user->attachRole($admin);
//Create user permissions
// $createPost = new Permission();
// $createPost->name = 'create-post';
// $createPost->display_name = 'create posts';
// $createPost->description = 'create new blog posts';
// $createPost->save();
//
// $updatePost = new Permission();
// $updatePost->name = 'update-post';
// $updatePost->display_name = 'update posts';
// $updatePost->description = 'update blog posts';
// $updatePost->save();
//
// $deletePost = new Permission();
// $deletePost->name = 'delete-post';
// $deletePost->display_name = 'delete posts';
// $deletePost->description = 'delete blog posts';
// $deletePost->save();
//
//Attach permission
// $admin->attachPermissions([
// $createPost,
// $updatePost,
// $deletePost
// ]);
}
/**
* Run the database seeds.
*
* @return void
*/
public function run()
{
$adminRole = new Role();
$adminRole->display_name = 'Administrator';
$adminRole->name = 'administrator';
$adminRole->description = 'System Administrator';
$adminRole->save();
$editorRole = new Role();
$editorRole->display_name = 'Manager';
$editorRole->name = 'manager';
$editorRole->description = 'System Manager';
$editorRole->save();
$employeeRole = new Role();
$employeeRole->display_name = 'Employee';
$employeeRole->name = 'employee';
$employeeRole->description = 'Employee';
$employeeRole->save();
}
/**
* Crea un nuevo rol.
*
* @return Response
*/
public function create(Request $request)
{
$data = $request->all();
foreach ($data as $key => $value) {
$data[$key] = strtolower($value);
}
$validator = Validator::make($data, ['name' => 'required|between:4,100|alpha_dash|unique:roles', 'display_name' => 'between:0,100', 'description' => 'between:0,255']);
if ($validator->fails()) {
return response()->json(["msg" => "alert", "validator" => $validator->messages()], 200);
}
$role = new Role();
$role->name = $data['name'];
$role->display_name = $data['display_name'];
// optional
$role->description = $data['description'];
// optional
$role->save();
return response()->json(["msg" => "success", "id" => $role->id], 200);
}
