/**
* handle group creation logic
*
* @param Validator $validator
* @param Dispatcher $dispatcher
* @param Group $group
* @return CommandResult
*/
public function handle(Validator $validator, Dispatcher $dispatcher, Group $group)
{
// check user permission
if (!$this->disablePermissionChecking) {
if (!$this->user->hasAnyPermission(['user.manage'])) {
return new CommandResult(false, CommandResult::$responseForbiddenMessage, null, 403);
}
}
// validate data
$validationResult = $validator->make(array('name' => $this->name, 'permissions' => $this->permissions), Group::$rules);
if ($validationResult->fails()) {
return new CommandResult(false, $validationResult->getMessageBag()->first(), null, 400);
}
// prepare data to be store
$groupToBeCreated = array('name' => $this->name, 'permissions' => $this->transform($this->permissions));
// fire creating
$dispatcher->fire('group.creating', array($groupToBeCreated));
// create
$createdGroup = $group->create($groupToBeCreated);
if (!$createdGroup) {
return new CommandResult(false, "Failed to create user.", null, 400);
}
// fire created user
$dispatcher->fire('group.created', array($createdGroup));
// return response
return new CommandResult(true, "Group successfully created.", $createdGroup, 201);
}
protected function createGroups()
{
// create dummy groups
$blogger = Group::create(array('name' => 'blogger', 'permissions' => array('blog.list' => 1, 'blog.create' => 1, 'blog.edit' => 1, 'blog.delete' => -1)));
$artist = Group::create(array('name' => 'artist', 'permissions' => array('blog.list' => -1, 'art.create' => 1, 'art.edit' => 1, 'art.delete' => -1)));
$moderator = Group::create(array('name' => 'moderator', 'permissions' => array('blog.list' => -1, 'art.create' => 1, 'art.edit' => 1, 'art.delete' => -1)));
}
protected function createDummyUserAndGroup()
{
$blogger = Group::create(array('name' => 'blogger', 'permissions' => array('blog.list' => -1, 'art.create' => 1, 'art.edit' => 1, 'art.delete' => -1)));
$user = User::create(array('first_name' => 'jane', 'last_name' => 'stark', 'email' => '*****@*****.**', 'password' => 'pass$jane', 'permissions' => array('blog.create' => 0, 'forum.create' => 0)));
$user->groups()->attach($blogger);
return array('blogger' => $blogger, 'user' => $user);
}
public function testShouldUpdate()
{
// create user and logged in (the user who will perform the action)
$user = User::create(array('first_name' => 'darryl', 'email' => '*****@*****.**', 'password' => 'pass$darryl', 'permissions' => array('superuser' => 1)));
$this->application['auth']->loginUsingId($user->id);
// create the group that we will be updating
$blogger = Group::create(array('name' => 'blogger', 'permissions' => array('blog.list' => 1, 'blog.create' => 1, 'blog.edit' => 1, 'blog.delete' => -1)));
// dummy request
// we will update the blogger group that it will not be able to create a blog now
$request = Request::create('', 'POST', array('id' => $blogger->id, 'name' => 'blogger-renamed', 'permissions' => array('blog.list' => 1, 'blog.create' => -1, 'blog.edit' => 1, 'blog.delete' => -1)));
// begin
$result = $this->commandDispatcher->dispatchFromArray('Darryldecode\\Backend\\Components\\User\\Commands\\UpdateGroupCommand', array('id' => $request->get('id', null), 'name' => $request->get('name', null), 'permissions' => $request->get('permissions', array())));
$this->assertTrue($result->isSuccessful(), 'Transaction should be successful.');
$this->assertEquals(200, $result->getStatusCode(), 'Status code should be 200.');
$this->assertEquals('Group successfully updated.', $result->getMessage());
// now prove it has been updated
$updatedGroup = Group::find($result->getData()->id);
//$this->assertEquals('blogger-renamed', $updatedGroup->name);
$this->assertArrayHasKey('blog.list', $updatedGroup->getPermissionsAttribute(), 'Group permissions should have key blog.list');
$this->assertArrayHasKey('blog.create', $updatedGroup->getPermissionsAttribute(), 'Group permissions should have key blog.create');
$this->assertArrayHasKey('blog.edit', $updatedGroup->getPermissionsAttribute(), 'Group permissions should have key blog.edit');
$this->assertArrayHasKey('blog.delete', $updatedGroup->getPermissionsAttribute(), 'Group permissions should have key blog.delete');
$this->assertEquals(1, $updatedGroup->getPermissionsAttribute()['blog.list'], 'Permission blog.list should be allow');
$this->assertEquals(-1, $updatedGroup->getPermissionsAttribute()['blog.create'], 'Permission blog.create should be deny');
$this->assertEquals(1, $updatedGroup->getPermissionsAttribute()['blog.edit'], 'Permission blog.edit should be allow');
$this->assertEquals(-1, $updatedGroup->getPermissionsAttribute()['blog.delete'], 'Permission blog.delete should be deny');
}
protected function createUserAndLoggedIn()
{
$group = Group::create(array('name' => 'blogger', 'permissions' => array('superuser' => 1)));
$user = User::create(array('first_name' => 'darryl', 'email' => '*****@*****.**', 'password' => 'pass$darryl', 'permissions' => array('blog.create' => 0, 'forum.create' => 0)));
$user->groups()->attach($group);
$this->application['auth']->loginUsingId($user->id);
return $user;
}
/**
* handle user deletion logic
*
* @param User $user
* @param Group $group
* @param Dispatcher $dispatcher
* @return CommandResult
*/
public function handle(User $user, Group $group, Dispatcher $dispatcher)
{
// check user permission
if (!$this->disablePermissionChecking) {
if (!$this->user->hasAnyPermission(['user.delete'])) {
return new CommandResult(false, CommandResult::$responseForbiddenMessage, null, 403);
}
}
// find the group
if (!($groupToBeDelete = $group->with('users')->find($this->id))) {
return new CommandResult(false, "Group not found.", null, 404);
}
// fire deleting
$dispatcher->fire('group.deleting', array($this->args));
// begin deletion
$groupToBeDelete->users()->detach();
$groupToBeDelete->delete();
// fire deleted
$dispatcher->fire('group.deleted', array($groupToBeDelete));
// all good
return new CommandResult(true, "Group successfully deleted.", null, 200);
}
/**
* handle group command update logic
*
* @param Group $group
* @param Dispatcher $dispatcher
* @param Validator $validator
* @return CommandResult
*/
public function handle(Group $group, Dispatcher $dispatcher, Validator $validator)
{
// check user permission
if (!$this->disablePermissionChecking) {
if (!$this->user->hasAnyPermission(['user.manage'])) {
return new CommandResult(false, CommandResult::$responseForbiddenMessage, null, 403);
}
}
// fire updating
$dispatcher->fire('group.updating', array($this->args));
// try to find group to be updated
if (!($groupToBeUpdated = $group->find($this->id))) {
return new CommandResult(false, "Group not found.", null, 400);
}
// begin update
$groupToBeUpdated->name = $this->name ? $this->name : $groupToBeUpdated->name;
$groupToBeUpdated->permissions = $this->permissions ? $this->transform($this->permissions) : $groupToBeUpdated->permissions;
$groupToBeUpdated->save();
// fire creating
$dispatcher->fire('group.updated', array($groupToBeUpdated));
// all good
return new CommandResult(true, "Group successfully updated.", $groupToBeUpdated, 200);
}
/**
* @param \Darryldecode\Backend\Components\User\Models\Group $group
* @param \Illuminate\Contracts\Events\Dispatcher $dispatcher
* @return \Darryldecode\Backend\Base\Commands\CommandResult
*/
public function handle(Group $group, Dispatcher $dispatcher)
{
// check user permission
if (!$this->disablePermissionChecking) {
if (!$this->user->hasAnyPermission(['user.manage'])) {
return new CommandResult(false, CommandResult::$responseForbiddenMessage, null, 403);
}
}
// fire before query event
$dispatcher->fire('groups.beforeQuery', array($this->args));
// begin
$q = $group->with(array_merge(array('users'), $this->with))->ofName($this->name);
// give paginated results if told so
if ($this->paginate) {
$results = $q->paginate($this->perPage);
} else {
$results = $q->get();
}
// fire after query event
$dispatcher->fire('groups.afterQuery', array($results));
// all good
return new CommandResult(true, "Query groups command successful.", $results, 200);
}
/**
* @param User $user
* @param Dispatcher $dispatcher
* @param Group $group
* @return CommandResult
*/
public function handle(User $user, Dispatcher $dispatcher, Group $group)
{
// check user permission
if (!$this->disablePermissionChecking) {
if (!$this->user->hasAnyPermission(['user.manage'])) {
return new CommandResult(false, CommandResult::$responseForbiddenMessage, null, 403);
}
}
// fire creating
$dispatcher->fire('user.updating', array($this->args));
// find the user to be updated
if (!($userToBeUpdated = $user->find($this->id))) {
return new CommandResult(false, "User not found.", null, 404);
}
// begin update
$userToBeUpdated->first_name = $this->firstName ? $this->firstName : $userToBeUpdated->first_name;
$userToBeUpdated->last_name = $this->lastName ? $this->lastName : $userToBeUpdated->last_name;
$userToBeUpdated->permissions = $this->isPermissionsProvided($this->permissions) ? $this->transform($this->permissions) : $userToBeUpdated->permissions;
if ($this->isEmailIsProvidedAndIsNew($userToBeUpdated->email, $this->email)) {
if ($this->isEmailAlreadyInUsed($user, $this->email)) {
return new CommandResult(false, "Email already in used.", null, 400);
} else {
$userToBeUpdated->email = $this->email;
}
}
if ($this->isPasswordIsProvided()) {
$userToBeUpdated->password = $this->password;
}
// save
$userToBeUpdated->save();
// add to group if there's any
if ($this->isGroupIdsAreProvided($this->groups)) {
// delete all groups first
$userToBeUpdated->groups()->detach();
// re attach
foreach ($this->groups as $groupId) {
$g = $group->find($groupId);
if ($g) {
$userToBeUpdated->groups()->attach($g);
}
}
}
// fire created user
$dispatcher->fire('user.updated', array($userToBeUpdated));
// return response
return new CommandResult(true, "User successfully updated.", $userToBeUpdated, 200);
}
public function testQueryWithGroupId()
{
// create dummy groups
$blogger = Group::create(array('name' => 'blogger', 'permissions' => array('blog.list' => 1, 'blog.create' => 1, 'blog.edit' => 1, 'blog.delete' => -1)));
// create user and logged in (the user who will perform the action)
$user = User::create(array('first_name' => 'dianne', 'last_name' => 'monte', 'email' => '*****@*****.**', 'password' => 'pass$dianne', 'permissions' => array('user.manage' => 1)));
$user->groups()->attach($blogger);
// logged in the user
$this->application['auth']->loginUsingId($user->id);
$this->createUsers();
// ----------------------
// begin query by group
// ----------------------
$result = $this->commandDispatcher->dispatchFromArray('Darryldecode\\Backend\\Components\\User\\Commands\\QueryUsersCommand', array('firstName' => null, 'lastName' => null, 'email' => null, 'groupId' => $blogger->id, 'with' => array(), 'orderBy' => 'created_at', 'orderSort' => 'ASC', 'paginated' => true, 'perPage' => 15));
$this->assertTrue($result->isSuccessful());
$this->assertCount(1, $result->getData()->toArray()['data'], 'should only find 1 item');
$this->assertEquals('dianne', $result->getData()->first()->first_name, 'should only find 1 item');
}
public function testCreateShouldCreateGroupWhenAllCheckPointsPassed()
{
// create user and logged in (the user who will perform the action)
$user = User::create(array('first_name' => 'darryl', 'email' => '*****@*****.**', 'password' => 'pass$darryl', 'permissions' => array('superuser' => 1)));
$this->application['auth']->loginUsingId($user->id);
// dummy request
$request = Request::create('', 'POST', array('name' => 'moderator', 'permissions' => array('forum.create' => 1, 'forum.delete' => -1)));
// begin
$result = $this->commandDispatcher->dispatchFrom('Darryldecode\\Backend\\Components\\User\\Commands\\CreateGroupCommand', $request);
$this->assertTrue($result->isSuccessful(), 'Transaction should be successful.');
$this->assertEquals(201, $result->getStatusCode(), 'Status code should be created.');
$this->assertEquals('Group successfully created.', $result->getMessage());
// prove persisted
$group = Group::find($result->getData()->id);
//$this->assertEquals('moderator',$group->name); this pass but just comment it because IDE skwaks!
$this->assertInternalType('array', $group->permissions);
$this->assertCount(2, $group->permissions);
$this->assertArrayHasKey('forum.create', $group->permissions);
$this->assertArrayHasKey('forum.delete', $group->permissions);
}
/**
* @param User $user
* @param Factory $validator
* @param Dispatcher $dispatcher
* @param Group $group
* @param Repository $config
* @return CommandResult
*/
public function handle(User $user, Factory $validator, Dispatcher $dispatcher, Group $group, Repository $config)
{
// check user permission
if (!$this->disablePermissionChecking) {
if (!$this->user->hasAnyPermission(['user.manage'])) {
return new CommandResult(false, CommandResult::$responseForbiddenMessage, null, 403);
}
}
// prepare the user model
$user = $this->createUserModel($user, $config);
// validate data
$validationResult = $validator->make(array('first_name' => $this->firstName, 'last_name' => $this->lastName, 'email' => $this->email, 'password' => $this->password), $user->getValidationRules());
if ($validationResult->fails()) {
return new CommandResult(false, $validationResult->getMessageBag()->first(), null, 400);
}
// prepare data to be store
$userDataToBeCreated = array('first_name' => $this->firstName, 'last_name' => $this->lastName, 'email' => $this->email, 'password' => $this->password, 'permissions' => $this->transform($this->permissions));
// fire creating
$dispatcher->fire('user.creating', array($userDataToBeCreated));
$createdUser = $user->create($userDataToBeCreated);
if (!$createdUser) {
return new CommandResult(false, "Failed to create user.", null, 400);
}
// add to group if there's any
if (count($this->groups) > 0) {
foreach ($this->groups as $groupId) {
$g = $group->find($groupId);
if ($g) {
$createdUser->groups()->attach($g);
}
}
}
// fire created user
$dispatcher->fire('user.created', array($createdUser));
// return response
return new CommandResult(true, "User successfully created.", $createdUser, 201);
}
protected function seedUser()
{
$group = \Darryldecode\Backend\Components\User\Models\Group::create(array('name' => 'Super User', 'permissions' => array('superuser' => 1)));
$user = \Darryldecode\Backend\Components\User\Models\User::create(array('first_name' => 'John', 'last_name' => 'Doe', 'email' => '*****@*****.**', 'password' => 'admin', 'permissions' => array('superuser' => 1)));
$user->groups()->attach($group);
}
public function testUserInGroup()
{
$blogger = Group::create(array('name' => 'blogger', 'permissions' => array('blog.list' => 1, 'blog.create' => 1, 'blog.edit' => 1, 'blog.delete' => -1)));
$artist = Group::create(array('name' => 'artist', 'permissions' => array('blog.list' => -1, 'art.create' => 1, 'art.edit' => 1, 'art.delete' => -1)));
$user = User::create(array('first_name' => 'darryl', 'last_name' => 'Fernandez', 'email' => '*****@*****.**', 'password' => 'pass$darryl', 'permissions' => array('blog.create' => 0, 'forum.create' => 0)));
$user->groups()->attach($blogger);
$user->groups()->attach($artist);
// by using the group object
$this->assertTrue($user->inGroup($blogger));
// by using the group name
$this->assertTrue($user->inGroup($blogger->name));
}
public function testShouldAssociateTheUserToTheGroupIfThereIsAnyProvided()
{
// create user and logged in
$user = User::create(array('first_name' => 'darryl', 'email' => '*****@*****.**', 'password' => 'pass$darryl', 'permissions' => array('superuser' => 1)));
$this->application['auth']->loginUsingId($user->id);
// create dummy groups
$blogger = Group::create(array('name' => 'blogger', 'permissions' => array('blog.list' => 1, 'blog.create' => 1, 'blog.edit' => 1, 'blog.delete' => -1)));
$artist = Group::create(array('name' => 'artist', 'permissions' => array('blog.list' => -1, 'art.create' => 1, 'art.edit' => 1, 'art.delete' => -1)));
$moderator = Group::create(array('name' => 'moderator', 'permissions' => array('blog.list' => -1, 'art.create' => 1, 'art.edit' => 1, 'art.delete' => -1)));
// dummy request, required first name
$request = Request::create('', 'GET', array('firstName' => 'Darryl', 'lastName' => 'Fernandez', 'email' => '*****@*****.**', 'password' => 'password', 'permissions' => array(), 'groups' => array($blogger->id, $artist->id)));
// begin
$result = $this->commandDispatcher->dispatchFrom('Darryldecode\\Backend\\Components\\User\\Commands\\CreateUserCommand', $request);
$createdUser = User::find($result->getData()->id);
$this->assertTrue($createdUser->inGroup($blogger), 'User should be in blogger group');
$this->assertTrue($createdUser->inGroup($artist), 'User should be in artist group');
$this->assertFalse($createdUser->inGroup($moderator), 'User should not be in moderator group');
}
