/**
  * GET /account(/:name).
  *
  * @param null|string $name
  */
 public function viewAccountAction($name = null)
 {
     $redis = $this->app->container->get('redis.client');
     $userRepository = new UserRepository($redis);
     $user = $userRepository->find($name);
     $jsonPath = $this->app->config('json_path') . 'users/github/' . $name . '.json';
     $this->app->notFoundIf(file_exists($jsonPath) === false)->redirectUnless($name, '/profile')->render('account.html', ['account' => $user]);
 }

 public static function ChangePassword($oldPassword, $newPassword)
 {
     $userRepository = new UserRepository();
     $user = $userRepository->LoadWhere("Id = " . self::$userId)[0];
     if ($user["Password"] == self::Encode($oldPassword)) {
         $userRepository->UpdateWhere("Id = " . self::$userId, ["Password" => self::Encode($newPassword)]);
         return true;
     } else {
         return false;
     }
 }

 /**
  * log the user - if not exists register him/her and then log the user
  *
  * @return	void
  */
 public static function userLogin()
 {
     $errors = array();
     $hash = addslashes(Utils::get('hash'));
     if ($hash) {
         $userRepository = new UserRepository();
         $user = $userRepository->getOneByHash($hash);
     } else {
         if (Utils::post('username') != '') {
             $username = addslashes(Utils::post('username'));
             if (!ctype_alnum($username)) {
                 $errors['username'] = 'V používateľskom mene môžeš použiť len alfanumerické znaky';
                 // TODO localize
             }
         } else {
             $errors['username'] = 'Musíš vyplniť používateľské meno';
             // TODO localize
         }
         if (Utils::post('password') != '') {
             $password = md5(addslashes(Utils::post('password')));
         } else {
             $errors['password'] = 'Musíš vyplniť heslo';
             // TODO localize
         }
         if (empty($errors)) {
             $userRepository = new UserRepository();
             $userExist = $userRepository->getOneByUsername($username);
             if ($userExist === NULL) {
                 $colorRepository = new ColorRepository();
                 $count = $colorRepository->getCountAll();
                 $rand = rand(1, $count);
                 $params = array('username' => $username, 'password' => $password, 'color' => $rand);
                 $user = new User($params);
                 $user = $user->save(TRUE);
             } elseif ($userExist['password'] != $password) {
                 $errors['password'] = 'Nesprávne heslo';
             } else {
                 $user = $userExist;
             }
         }
     }
     if ($user && empty($errors)) {
         // TODO po prihlaseni treba nejako zmazat v memcachi query, ktora vybera usera podla cookie_value
         // lebo teraz to stale vracia vysledok z memcache -> ked sa prihlasim v dvoch browsroch, v obidvoch to funguje
         // neodhlasi ma z toho prveho
         $cookieValue = md5(time() . $user['id'] . $user['username']);
         DB::update(DB_PREFIX . 'user', array('cookie_value' => $cookieValue), 'id = ' . $user['id']);
         $expire = Utils::post('remember') == 1 ? strtotime('+1 year') : 0;
         setcookie(self::$cookieName, $cookieValue, $expire, '/');
         return TRUE;
     } else {
         return $errors;
     }
 }

 public function __construct()
 {
     parent::__construct();
     $this->create_guest_account = function () {
         return UserRepository::createWithRoles(['UserID' => 1, 'Name' => 'Anonymous', 'Password' => str_random(64), 'HashMethod' => 'random'], [RoleRepository::member()]);
     };
 }

 public function ShowUserAttributes()
 {
     // User attributes on Dashboard, Added by Burak C.
     $userId = ServiceLocator::GetServer()->GetUserSession()->UserId;
     $userRepository = new UserRepository();
     $this->user = $userRepository->LoadById($userId);
     $attributeService = new AttributeService(new AttributeRepository());
     $attributes = $attributeService->GetByCategory(CustomAttributeCategory::USER);
     $reservationViewRepository = new ReservationViewRepository();
     $startDate = Date::Now();
     $endDate = $startDate->AddDays(30);
     $reservations = $reservationViewRepository->GetReservationList($startDate, $endDate, $userId, ReservationUserLevel::INVITEE);
     $this->_page->Set("invitations", $reservations);
     $this->_page->Set("user", $this->user);
     $this->_page->Set("attributes", $attributes);
 }

 public function SendRandomPassword()
 {
     $emailAddress = $this->_page->GetEmailAddress();
     Log::Debug('Password reset request for email address %s requested from REMOTE_ADDR: %s REMOTE_HOST: %s', $emailAddress, $_SERVER['REMOTE_ADDR'], $_SERVER['REMOTE_HOST']);
     $temporaryPassword = Password::GenerateRandom();
     $passwordEncryption = new PasswordEncryption();
     $salt = $passwordEncryption->Salt();
     $encrypted = $passwordEncryption->Encrypt($temporaryPassword, $salt);
     $userRepository = new UserRepository();
     $user = $userRepository->FindByEmail($emailAddress);
     if ($user != null) {
         $user->ChangePassword($encrypted, $salt);
         $userRepository->Update($user);
         $emailMessage = new ForgotPasswordEmail($user, $temporaryPassword);
         ServiceLocator::GetEmailService()->Send($emailMessage);
     }
 }

 /**
  * Check to see if the specification is satisfied
  *
  * @param Username $username
  * @return bool
  */
 public function isSatisfiedBy(Username $username)
 {
     if (!$this->repository->userOfUsername($username)) {
         return true;
     }
     return false;
 }

 /**
  * Bind data to the view.
  *
  * @param  View  $view
  * @return void
  */
 public function compose(View $view)
 {
     if (!Cache::get('recent_posts')) {
         Cache::put('recent_posts', $this->posts->getAll('published', null, 'published_at', 'desc', 5), 10);
     }
     $view->with('recent_posts', Cache::get('recent_posts'));
 }

 public function handleSave(Form $form)
 {
     $values = $form->values;
     if ($values['file']->isOk()) {
         if ($values['cleanout']) {
             foreach ($this->userRepository->findAll() as $user) {
                 $this->userRepository->delete($user);
             }
         }
         /** @var FileUpload $file */
         $file = $values['file'];
         $data = file_get_contents($file->getTemporaryFile());
         foreach (explode("\n", $data) as $row) {
             if (!$row) {
                 continue;
             }
             $items = explode(',', $row);
             if (!count($items)) {
                 continue;
             }
             try {
                 $user = new UserEntity(trim($items[0]));
             } catch (InvalidArgumentException $e) {
                 $form->addError($e->getMessage());
             }
             $this->userRepository->save($user);
         }
     }
 }

 /**
  * Check to see if the specification is satisfied
  *
  * @param Email $email
  * @return bool
  */
 public function isSatisfiedBy(Email $email)
 {
     if (!$this->repository->userOfEmail($email)) {
         return true;
     }
     return false;
 }

 /** @test */
 public function it_unfollows_another_user()
 {
     $users = TestDummy::times(2)->create('Larabook\\Users\\User');
     $this->repo->follow($users[1]->id, $users[0]);
     $this->repo->unfollow($users[1]->id, $users[0]);
     $this->tester->dontSeeRecord('follows', ['follower_id' => $users[0]->id, 'followed_id' => $users[1]->id]);
 }

 /**
  * UnFollow user
  *
  * @param $input
  * @return mixed
  */
 public function unFollowUser($input)
 {
     $user = $this->userRepo->findById($input['user_id']);
     $userToUnFollow = $this->userRepo->findById($input['userIdToUnFollow']);
     $this->albumRepo->unShareAllAlbums($user, $userToUnFollow);
     return $this->userRepo->unFollow($input['userIdToUnFollow'], $user);
 }

 private function UpdateProfile(User $user)
 {
     $user->ChangeEmailPreference(new ReservationApprovedEvent(), $this->page->GetApproved());
     $user->ChangeEmailPreference(new ReservationCreatedEvent(), $this->page->GetCreated());
     $user->ChangeEmailPreference(new ReservationUpdatedEvent(), $this->page->GetUpdated());
     $user->ChangeEmailPreference(new ReservationDeletedEvent(), $this->page->GetDeleted());
     $this->userRepository->Update($user);
 }

 /** @test */
 public function should_register_new_user()
 {
     $this->repository->shouldReceive('userOfEmail')->once()->andReturn(null);
     $this->repository->shouldReceive('userOfUsername')->once()->andReturn(null);
     $this->repository->shouldReceive('nextIdentity')->once()->andReturn(UserId::generate());
     $this->repository->shouldReceive('add')->once();
     $user = $this->service->register('[email protected]', 'username', 'password');
     $this->assertInstanceOf('Cribbb\\Domain\\Model\\Identity\\User', $user);
 }

 /** @test */
 public function should_allow_user_to_join_the_group()
 {
     $user = m::mock('Cribbb\\Domain\\Model\\Identity\\User');
     $group = m::mock('Cribbb\\Domain\\Model\\Groups\\Group');
     $group->shouldReceive('addMember')->once();
     $this->users->shouldReceive('userById')->once()->andReturn($user);
     $this->groups->shouldReceive('groupById')->once()->andReturn($group);
     $group = $this->service->join('7c5e8127-3f77-496c-9bb4-5cb092969d89', 'a3d9e532-0ea8-4572-8e83-119fc49e4c6f');
     $this->assertInstanceOf('Cribbb\\Domain\\Model\\Groups\\Group', $group);
 }

 /**
  * Using the given email finds the user and verifies it's password.
  * If the user is not fund or if the password is wrong, it throws.
  *
  * @param array $credentials
  * @throws AuthenticationException
  * @return User|NULL
  */
 public function authenticate(array $credentials)
 {
     list($username, $password) = $credentials;
     if (!($user = $this->userRepository->findOneBy(['email' => $username]))) {
         throw new AuthenticationException("User '{$username}' not found.", self::IDENTITY_NOT_FOUND);
     } elseif (!$user->verifyPassword($password)) {
         throw new AuthenticationException('Invalid password.', self::INVALID_CREDENTIAL);
     }
     return $user;
 }

 /** @test */
 public function should_reset_password_and_return_user()
 {
     $reminder = new Reminder($this->fixture['id'], $this->fixture['email'], $this->fixture['code']);
     $this->reminders->shouldReceive('findReminderByEmailAndCode')->andReturn($reminder);
     $this->users->shouldReceive('userOfEmail')->andReturn($this->user);
     $this->hasher->shouldReceive('hash')->andReturn(new HashedPassword('qwerty123'));
     $this->users->shouldReceive('update');
     $this->reminders->shouldReceive('deleteReminderByCode');
     $user = $this->service->reset('[email protected]', 'qwerty123', 'abc123');
     $this->assertInstanceOf('Cribbb\\Domain\\Model\\Identity\\User', $user);
 }

 /** @test */
 public function should_register_new_user()
 {
     $this->repository->shouldReceive('userOfEmail')->andReturn(null);
     $this->repository->shouldReceive('userOfUsername')->andReturn(null);
     $this->repository->shouldReceive('nextIdentity')->andReturn($this->uuid);
     $this->hashing->shouldReceive('hash')->andReturn($this->password);
     $this->repository->shouldReceive('add');
     $this->dispatcher->shouldReceive('dispatch');
     $user = $this->service->registerUser('[email protected]', 'username', 'password');
     $this->assertInstanceOf('Cribbb\\Domain\\Model\\Identity\\User', $user);
 }

 /** @test */
 public function should_create_new_post()
 {
     $user = m::mock('Cribbb\\Domain\\Model\\Identity\\User');
     $thread = m::mock('Cribbb\\Domain\\Model\\Discussion\\Thread');
     $post = m::mock('Cribbb\\Domain\\Model\\Discussion\\Post');
     $this->users->shouldReceive('userById')->once()->andReturn($user);
     $this->threads->shouldReceive('threadById')->once()->andReturn($thread);
     $thread->shouldReceive('createNewPost')->once()->andReturn($post);
     $this->posts->shouldReceive('add')->once();
     $post = $this->service->create('7c5e8127-3f77-496c-9bb4-5cb092969d89', 'a3d9e532-0ea8-4572-8e83-119fc49e4c6f', 'Hello World');
     $this->assertInstanceOf('Cribbb\\Domain\\Model\\Discussion\\Post', $post);
 }

 /** @test */
 public function should_create_new_thread()
 {
     $user = m::mock('Cribbb\\Domain\\Model\\Identity\\User');
     $group = m::mock('Cribbb\\Domain\\Model\\Groups\\Group');
     $thread = m::mock('Cribbb\\Domain\\Model\\Discussion\\Thread');
     $this->users->shouldReceive('userById')->once()->andReturn($user);
     $this->groups->shouldReceive('groupById')->once()->andReturn($group);
     $group->shouldReceive('startNewThread')->once()->andReturn($thread);
     $this->threads->shouldReceive('add')->once();
     $thread = $this->service->create('7c5e8127-3f77-496c-9bb4-5cb092969d89', 'a3d9e532-0ea8-4572-8e83-119fc49e4c6f', 'Hello World');
     $this->assertInstanceOf('Cribbb\\Domain\\Model\\Discussion\\Thread', $thread);
 }