/**
* Get the API ancestor controller class
* of the current controller class.
*
* @return Esensi\Core\Http\Controllers\ApiController
*/
public function api()
{
// Make a copy of the parent class
$class = get_parent_class();
$parent = App::make($class);
// Copy over the packaged properties
if ($this instanceof PackagedInterface) {
$parent->setUI($this->getUI());
$parent->setPackage($this->getPackage());
$parent->setNamespacing($this->getNamespacing());
}
// Copy over the injected repositories
if ($this instanceof RepositoryInjectedInterface) {
foreach ($this->repositories as $name => $repository) {
$parent->setRepository($repository, $name);
}
}
// Return first ApiController ancestor found
if (str_contains($class, 'ApiController')) {
return $parent;
}
// Recursively look up the parent class
if (method_exists($parent, 'api')) {
return $parent->api();
}
// Return the parent class found already
return $parent;
}
/**
* Do the Artisan commands fire?
*/
public function testCommands()
{
$self = $this;
$this->prepareSpecify();
$this->specify('Boots', function () use($self) {
$target = $self->getProvider(['package']);
$target->shouldReceive('package');
$target->boot();
});
$this->prepareSpecify();
$this->specify('Identifies provisions', function () use($self) {
$target = $self->getProvider();
verify($target->provides())->notEmpty();
});
$this->prepareSpecify();
$this->specify('Binds to application', function () use($self) {
App::shouldReceive('bind')->with('/^toolbox\\.commands\\./', Mockery::on(function ($closure) {
$command = $closure();
verify_that('is a command', is_a($command, 'Illuminate\\Console\\Command'));
return true;
}));
Event::shouldReceive('listen')->with('toolbox.build', Mockery::on(function ($closure) {
$app = Mockery::mock('Illuminate\\Console\\Application[call]');
$app->shouldReceive('call');
$command = $closure($app);
return true;
}));
$target = $self->getProvider(['commands']);
$target->shouldReceive('commands')->with(Mockery::type('array'));
$target->register();
});
}
/**
* @param string $lang
*/
private function setSupportedLanguage($lang)
{
if ($this->isLanguageSupported($lang)) {
App::setLocale($lang);
Session::put('lang', $lang);
}
}
/**
* Display the password reset view for the given token.
*
* @param string $token
* @return \Response
*/
public function getReset($token = null)
{
if (is_null($token)) {
App::abort(404);
}
$this->view('password.reset', ['token' => $token]);
}
/**
* Display the content of the page
*
* @param $query
* @return \Illuminate\View\View
*/
public function display($query)
{
$title = 'TestView';
$page = "";
$arr = explode('/', $query);
// \App\Page::find(4)->content->find(5)->element->module->name
$heading = \App\Node::findBySlug('header');
// dd(\App\Node::findBySlug($arr[0])->content);
// test
$content = \App\Node::active()->findBySlug($arr[0])->content;
foreach ($content as $item) {
// get the module Name of
// $module = \App\Module::findOrFail($p->module_id);
// resolve the Module Name out of the IOC Container and render the content partiall
// $content .= App::make('module:' . $module->name)->render($p->content_id);
// foreach ($item->content as $content)
// {
//Todo check if Module is Active and Content is Active
$module = $item->element->module->name;
if ($module != 'Heading') {
continue;
}
// resolve the Module out of the IOC Container and render the partial
$page .= App::make('module:' . strtolower($module))->render($item->element->row);
// }
}
return view('layout.master', compact('title', 'page'));
}
public function getTraining()
{
$training = new \Offside\Team\Training($this->trainingRepository);
$javascript = App::make('Javascript');
$javascript::put(['attackTraining' => $training->getAttackDateTime(), 'midfieldTraining' => $training->getMidfieldDateTime(), 'defenseTraining' => $training->getDefenseDateTime(), 'anyTrainingActive' => !$training->allTrainingsDone(), 'elapsedTime' => $training->getElapsedTime()]);
return view("my-team.training");
}
protected function bootSilverstripe($url = null)
{
$flush = $this->option('flush');
// to allow the Silverstripe command line to know what the server URL should be ...
// sadly, setting a global $_FILE_TO_URL_MAPPING variable is not enough because Silverstripe's Core.php (or
// Constants.php in newer versions) doesn't declare it as global - it assumes it's declared in the
// _ss_environment.php file which is _included_ not _required_. Boo.
// global $_FILE_TO_URL_MAPPING;
// $_FILE_TO_URL_MAPPING[base_path()] = Config::get('app.url');
$base = base_path();
$envPath = $base . '/_ss_environment.php';
if (!file_exists($envPath)) {
$appUrl = Config::get('app.url');
file_put_contents($envPath, <<<EOT
<?php
global \$_FILE_TO_URL_MAPPING;
\$_FILE_TO_URL_MAPPING['{$base}'] = '{$appUrl}';
EOT
);
App::shutdown(function ($app) use($envPath) {
unlink($envPath);
});
}
// taken from silverstripe's framework/cli-script.php
if ($flush) {
$_REQUEST['flush'] = $flush === true ? 1 : $flush;
$_GET['flush'] = $flush === true ? 1 : $flush;
}
if ($url) {
$_REQUEST['url'] = $url;
$_GET['url'] = $url;
}
Silverstripe::start();
}
/**
* Handle the command
*
* @param BaseCommand|RegisterUserCommand $command
*
* @return mixed
*/
public function handle(BaseCommand $command)
{
$user = new User($command->all());
$user->save();
App::make('Altwallets\\Services\\UserMailer')->sendRegistrationEmail($user);
return $user;
}
/**
* Register the application services.
*
* @return void
*/
public function register()
{
$this->mergeConfigFrom(__DIR__ . '/../../config/smsc.php', 'smsc');
App::bind('smsc', function () {
return new Smsc();
});
}
/**
* @test
*/
public function it_should_fire_job_with_unresolvable_models()
{
/**
*
* Set
*
*/
App::shouldReceive('make')->with('menthol.flexible.proxy', Mockery::any())->once()->andReturn('mock');
$app = m::mock('Illuminate\\Foundation\\Application');
$config = m::mock('Menthol\\Flexible\\Config');
$logger = m::mock('Monolog\\Logger');
$job = m::mock('Illuminate\\Queue\\Jobs\\Job');
$models = ['Husband:99999'];
/**
*
* Expectation
*
*/
$logger->shouldReceive('info')->with('Indexing Husband with ID: 99999');
$logger->shouldReceive('error')->with('Indexing Husband with ID: 99999 failed: No query results for model [Husband].');
$config->shouldReceive('get')->with('logger', 'menthol.flexible.logger')->andReturn('menthol.flexible.logger');
$app->shouldReceive('make')->with('menthol.flexible.logger')->andReturn($logger);
$job->shouldReceive('delete')->once();
$job->shouldReceive('release')->with(60)->once();
/**
*
* Assertion
*
*/
with(new ReindexJob($app, $config))->fire($job, $models);
}
public function __construct()
{
$this->request = App::make('request');
$this->config = App::make('config');
$this->restResponse = App::make('Noherczeg\\RestExt\\Services\\ResponseComposer');
$this->linker = App::make('Noherczeg\\RestExt\\Services\\Linker');
$this->restExt = App::make('Noherczeg\\RestExt\\RestExt');
if ($this->accessPolicy === null) {
$this->accessPolicy = $this->config->get('restext::access_policy');
}
// if we set the property it should override the Accept Header even if it it is set otherwise in the configs
if ($this->produces !== null) {
$this->produce($this->produces);
}
$securityRoles = $this->securityRoles;
$accessPolicy = $this->accessPolicy;
// Default actions
$this->beforeFilter(function () use($securityRoles, $accessPolicy) {
// To prevent processing / returning of content if by default the access policy is set to
// "whitelist" and no allowed roles have been set.
if ($accessPolicy == 'whitelist' && count($securityRoles) == 0) {
throw new PermissionException();
}
// If the "prefer_accept" configuration is set to true, we set RestResponse to send the MediaType given in
// the Accept Header if it's compatible with our system. If not we set it to the default config's value.
if ($this->config->get('restext::prefer_accept')) {
if (in_array($this->requestAccepts(), $this->restResponse->getSupportedMediaTypes())) {
$this->restResponse->setMediaType($this->requestAccepts());
}
$this->restResponse->setMediaType($this->config->get('restext::media_type'));
}
});
}
/**
* Profiler constructor.
*/
public function __construct()
{
$this->profiler = App::make('profiler');
if ($this->profiler instanceof NullProfiler) {
abort(500, 'Profiler is not instantiate correctly.');
}
}
/**
* @expectedException \Publiux\laravelcdn\Exceptions\MissingConfigurationException
*/
public function testCreateThrowsExceptionWhenMissingDefaultConfiguration()
{
$configurations = ['default' => ''];
$m_aws_s3 = M::mock('Publiux\\laravelcdn\\Providers\\AwsS3Provider');
\Illuminate\Support\Facades\App::shouldReceive('make')->once()->andReturn($m_aws_s3);
$this->provider_factory->create($configurations);
}
/**
* Returns an html icon class of the type of
* notification by retrieving it from the configuration file.
*
* @return string|null
*/
public function getIconAttribute()
{
$class = $this->attributes['notifiable_type'];
/*
* Resolve the configuration service from the IoC since
* we don't want to override the Notification models constructor
* to inject the service
*/
$config = App::make(ConfigService::class);
// Make sure we have an instance of the ConfigService returned by the IoC
if ($config instanceof ConfigService) {
$icon = $config->setPrefix('maintenance')->get("notifications.icons.{$class}");
// Return the models notification icon if it's found
if (is_string($icon) && !empty($icon)) {
return $icon;
}
/*
* Looks like the notification icon could not be
* found, we'll return the default notification icon
*/
$defaultIcon = $config->setPrefix('maintenance')->get('notifications.icons.default');
return $defaultIcon;
}
return;
}
/**
* Register any package services.
*
* @return void
*/
public function register()
{
App::bind('VKAPI', function () {
return new VKAPIClass(config('VKAPI.access_token'), config('VKAPI.version'), config('VKAPI.api_url'));
});
$this->publishes([__DIR__ . '/../config/VKAPI.php' => config_path('VKAPI.php')]);
}
/**
* Execute the console command.
*/
public function handle()
{
if (!preg_match('/' . Config::get('laravel-hash-store::config.filter', '^.+$') . '/', $this->argument('key'))) {
throw new Exception('Invalid hash key!');
}
$this->line('Hash created: ' . App::make('HashStore')->create($this->argument('key')));
}
/**
* @param Proxy $proxy
* @param string $name
*/
public function __construct(Proxy $proxy, $name = '')
{
self::$client = App::make('Elasticsearch');
self::$config = App::make('Menthol\\Flexible\\Config');
$this->setProxy($proxy);
$this->setName($name ?: $proxy->getModel()->getTable());
}
/**
* Index action.
*
* @return mixed
*/
public function getIndex($type = null)
{
$container = Input::get('c');
$files = Input::get('files', '');
if (empty($type) || !in_array($type, array('style', 'script'))) {
App::abort(404);
}
if (empty($container)) {
App::abort(404);
}
$files = json_decode(base64_decode($files), true);
if (empty($files) || !is_array($files)) {
App::abort(404);
}
foreach ($files as $file) {
Casset::container($container)->add(array_get($file, 'source'), array(), array_get($file, 'dependencies', array()));
}
$response = Response::make(Casset::container($container)->content($type));
if ('style' == $type) {
$response->headers->set('Content-Type', 'text/css');
} else {
$response->headers->set('Content-Type', 'application/json');
}
return $response;
}
/**
* Register the HTML builder instance.
* This binds the 'html' reference in the IoC container to the package implementation.
* Laravel's HTML Facade will automatically use this when being called
*
* @return void
*/
protected function registerHtmlBuilder()
{
$this->app->bindShared('html', function ($app) {
$urlGenerator = App::make(UrlGenerator::class);
return new HtmlBuilder($urlGenerator);
});
}
public function getInputs($inputs)
{
$inputs['datetime_ini'] = HelperRepository::date($inputs['datetime_ini'], App::getLocale());
$inputs['datetime_end'] = HelperRepository::date($inputs['datetime_end'], App::getLocale());
$inputs['cost'] = HelperRepository::money($inputs['cost'], App::getLocale());
return $inputs;
}
/**
* Retrieve a user by the given credentials.
* This will first authenticate against ldap before loading the user with eloquent
* @param array $credentials
* @return \Illuminate\Auth\UserInterface|null
*/
public function retrieveByCredentials(array $credentials)
{
$username = $credentials['username'];
$user = $this->createModel()->query()->where('username', $username)->first();
if ($user == null && ($this->config['autoRegister'] || isset($credentials['isRegister']))) {
//if our user wasn't found, and we have auto register enabled or we're coming from the user registration
//directly, then we'll attempt an authentication and take the appropriate action.
$ldap_info = $this->getAdLdap()->user()->info($username);
if ($ldap_info['count'] != 1) {
return null;
}
if ($this->getAdLdap()->authenticate($ldap_info[0]['dn'], $credentials['password'])) {
if ($this->config['autoRegister']) {
//if we have auto register enabled, create a user and such using the ldap info.
$ldapInfo = $this->getAdLdap()->user()->info($username, array("givenname", "sn"))[0];
$userInfo = array();
$userInfo['firstname'] = isset($ldapInfo['givenname']) ? $ldapInfo['givenname'][0] : $username;
$userInfo['lastname'] = isset($ldapInfo['sn']) ? $ldapInfo['sn'][0] : '';
$userInfo['username'] = $username;
$userInfo['password'] = '******';
$user = App::make('UserRegistrator')->registerUser($userInfo, $this->config['registrationLanguage']);
} elseif (isset($credentials['isRegister'])) {
//if we're not auto registering, but this is the registration process,
//we need to return a valid UserInterface object so that Guard will
//pass the authentication and actually continue with the registration process.
//This is necessary because we don't allow users that can't authenticate to ldap to register
$user = new GenericUser(array("id" => $username));
}
}
}
return $user;
}
public function __construct(QueryStringOperations $qso)
{
$this->queryStringOps = $qso;
$this->request = App::make('request');
$this->url = App::make('url');
$this->config = App::make('config');
}
/**
* Display a listing of the resource.
*
* @return Response
*/
public function index()
{
//
$pusher = App::make('pusher');
$pusher->trigger('test_channel', 'my_event', array('text' => Hash::make('pusher')));
return view('chat');
}
function phone_format($phone, $country, $format = null)
{
$lib = App::make('libphonenumber');
$phoneNumber = $lib->parse($phone, $country);
$format = is_null($format) ? PhoneNumberFormat::INTERNATIONAL : $format;
return $lib->format($phoneNumber, $format);
}
/**
* Integration Test.
*/
public function testPushCommand()
{
$configuration_file = ['bypass' => false, 'default' => 'AwsS3', 'url' => 'https://s3.amazonaws.com', 'threshold' => 10, 'providers' => ['aws' => ['s3' => ['region' => 'us-standard', 'version' => 'latest', 'buckets' => ['my-bucket-name' => '*'], 'acl' => 'public-read', 'cloudfront' => ['use' => false, 'cdn_url' => ''], 'metadata' => [], 'expires' => gmdate('D, d M Y H:i:s T', strtotime('+5 years')), 'cache-control' => 'max-age=2628000', 'version' => '']]], 'include' => ['directories' => [__DIR__], 'extensions' => [], 'patterns' => []], 'exclude' => ['directories' => [], 'files' => [], 'extensions' => [], 'patterns' => [], 'hidden' => true]];
$m_consol = M::mock('Symfony\\Component\\Console\\Output\\ConsoleOutput');
$m_consol->shouldReceive('writeln')->atLeast(1);
$finder = new \Vinelab\Cdn\Finder($m_consol);
$asset = new \Vinelab\Cdn\Asset();
$provider_factory = new \Vinelab\Cdn\ProviderFactory();
$m_config = M::mock('Illuminate\\Config\\Repository');
$m_config->shouldReceive('get')->with('cdn')->once()->andReturn($configuration_file);
$helper = new \Vinelab\Cdn\CdnHelper($m_config);
$m_console = M::mock('Symfony\\Component\\Console\\Output\\ConsoleOutput');
$m_console->shouldReceive('writeln')->atLeast(2);
$m_validator = M::mock('Vinelab\\Cdn\\Validators\\Contracts\\ProviderValidatorInterface');
$m_validator->shouldReceive('validate');
$m_helper = M::mock('Vinelab\\Cdn\\CdnHelper');
$m_spl_file = M::mock('Symfony\\Component\\Finder\\SplFileInfo');
$m_spl_file->shouldReceive('getPathname')->andReturn('vinelab/cdn/tests/Vinelab/Cdn/AwsS3ProviderTest.php');
$m_spl_file->shouldReceive('getRealPath')->andReturn(__DIR__ . '/AwsS3ProviderTest.php');
// partial mock
$p_aws_s3_provider = M::mock('\\Vinelab\\Cdn\\Providers\\AwsS3Provider[connect]', array($m_console, $m_validator, $m_helper));
$m_s3 = M::mock('Aws\\S3\\S3Client')->shouldIgnoreMissing();
$m_s3->shouldReceive('factory')->andReturn('Aws\\S3\\S3Client');
$m_command = M::mock('Aws\\Command');
$m_s3->shouldReceive('getCommand')->andReturn($m_command);
$m_s3->shouldReceive('execute');
$p_aws_s3_provider->setS3Client($m_s3);
$p_aws_s3_provider->shouldReceive('connect')->andReturn(true);
\Illuminate\Support\Facades\App::shouldReceive('make')->once()->andReturn($p_aws_s3_provider);
$cdn = new \Vinelab\Cdn\Cdn($finder, $asset, $provider_factory, $helper);
$result = $cdn->push();
assertEquals($result, true);
}
/**
* Return available payment methods by country and payment group
* Method parameters can be set via config
*
* @param string [Optional] $country
* @param array [Optional] $payment_groups_names
* @return array
*/
public static function getPaymentMethods($country = null, $payment_groups_names = null)
{
$payment_methods_info = WebToPay::getPaymentMethodList(intval(config('paysera.projectid')), config('paysera.currency'));
$country_code = !is_null($country) ? $country : strtolower(config('paysera.country'));
$payment_methods_info->setDefaultLanguage(App::getLocale());
$result = [];
$country_payment_methods_info = $payment_methods_info->getCountry($country_code);
$result['country_code'] = $country_payment_methods_info->getCode();
$result['country_title'] = $country_payment_methods_info->getTitle();
$payment_methods_groups_all = $country_payment_methods_info->getGroups();
if ($payment_groups_names == null) {
$payment_groups_names = config('paysera.payment_groups');
}
foreach ($payment_groups_names as $payment_groups_name) {
$payment_methods_groups[$payment_groups_name] = $payment_methods_groups_all[$payment_groups_name];
$result['payment_groups'][$payment_groups_name]['title'] = $payment_methods_groups_all[$payment_groups_name]->getTitle(App::getLocale());
foreach ($payment_methods_groups_all[$payment_groups_name]->getPaymentMethods() as $key => $method) {
$tmp = [];
$tmp['title'] = $method->getTitle(App::getLocale());
$tmp['key'] = $key;
$tmp['currency'] = $method->getBaseCurrency();
$tmp['logo_url'] = $method->getLogoUrl();
$tmp['object'] = $method;
$result['payment_groups'][$payment_groups_name]['methods'][$key] = $tmp;
}
}
return $result;
}
/**
* @test
*/
public function it_should_bind_index()
{
/**
* Set
*/
App::clearResolvedInstances();
App::shouldReceive('make')->with('menthol.flexible.index', m::any())->once()->andReturn('mock');
App::shouldReceive('make')->with('Elasticsearch')->twice()->andReturn('mock');
$config = m::mock('Menthol\\Flexible\\Config');
App::shouldReceive('make')->with('Menthol\\Flexible\\Config')->once()->andReturn($config);
$config->shouldReceive('get')->with('elasticsearch.index_prefix', '')->andReturn('');
$model = m::mock('Illuminate\\Database\\Eloquent\\Model');
$model->shouldReceive('getTable')->once()->andReturn('mockType');
$app = m::mock('LaravelApp');
$proxy = m::mock('Menthol\\Flexible\\Proxy', [$model]);
$sp = m::mock('Menthol\\Flexible\\FlexibleServiceProvider[bindIndex]', [$app]);
/**
* Expectation
*/
$app->shouldReceive('bind')->once()->andReturnUsing(function ($name, $closure) use($app, $proxy) {
$this->assertEquals('menthol.flexible.index', $name);
$this->assertInstanceOf('Menthol\\Flexible\\Index', $closure($app, ['proxy' => $proxy, 'name' => 'name']));
});
/**
* Assertion
*/
$sp->bindIndex();
}
public function testInstallationAlreadyCompleted()
{
$this->mockAccountManagementService->shouldReceive('totalNumberOfAccounts')->andReturn(1);
App::shouldReceive('abort')->with(404)->once();
$this->middleware->handle('request', function () {
});
}
public function getIndex($profileId)
{
$profile = Profile::where('id', '=', $profileId)->first();
if ($profile && $profile->isActive == 1) {
session(['profileId' => $profileId]);
$vote = Vote::where(['user_id' => Auth::id(), 'profile_id' => $profileId])->first();
$voted = false;
if ($vote && $vote->isActive == 1) {
$voted = true;
}
$photos = [];
if ($profile->photo1 != '') {
$photos[] = $profile->photo1;
}
if ($profile->photo2 != '') {
$photos[] = $profile->photo2;
}
if ($profile->photo3 != '') {
$photos[] = $profile->photo3;
}
if ($profile->photo4 != '') {
$photos[] = $profile->photo4;
}
if ($profile->photo5 != '') {
$photos[] = $profile->photo5;
}
$fb = App::make('SammyK\\LaravelFacebookSdk\\LaravelFacebookSdk');
$user = User::where('id', '=', $profile->user_id)->first();
$data = array('selectedPage' => 1, 'profile' => $profile, 'user' => $user, 'fbLink' => $fb->getLoginUrl(['email']), 'votes' => $profile->votes()->where('isActive', '1')->paginate($this->pictures_lazy_load), 'total_votes' => $profile->votes()->where('isActive', '1')->count(), 'voted' => $voted, 'photos' => $photos, 'pageUrl' => env('BASE_FB_URL') . 'profile/index/' . $profile->id);
return view('profile.index', $data);
} else {
echo 'profile not found';
}
}
/**
* Controller Auto-Router
*
* @param string $controller eg. 'Admin\\UserController'
* @param array $request_methods eg. array('get', 'post', 'put', 'delete')
* @param string $prefix eg. admin.users
* @param array $disallowed eg. array('private_method that starts with one of request methods)
* @return Closure
*/
public static function autoRoute($controller, $request_methods, $disallowed = array(), $prefix = '')
{
return function () use($controller, $prefix, $disallowed, $request_methods) {
//get all defined functions
$methods = get_class_methods(App::make($controller));
//laravel methods to disallow by default
$disallowed_methods = array('getBeforeFilters', 'getAfterFilters', 'getFilterer');
//build list of functions to not allow
if (is_array($disallowed)) {
$disallowed_methods = array_merge($disallowed_methods, $disallowed);
}
//if there is a index method then lets just bind it and fill the gap in route_names
if (in_array('getIndex', $methods)) {
Lara::fillRouteGaps($prefix, $controller . '@getIndex');
}
//over all request methods, get, post, etc
foreach ($request_methods as $type) {
//filter functions that starts with request method and not in disallowed list
$actions = array_filter($methods, function ($action) use($type, $disallowed_methods) {
return Str::startsWith($action, $type) && !in_array($action, $disallowed_methods);
});
foreach ($actions as $action) {
$controller_route = $controller . '@' . $action;
// Admin\\Controller@get_login
$url = Str::snake(str_replace($type, '', $action));
// login; snake_case
//double check and dont bind to already bound gaps filled index
if (in_array($action, $methods) && $action !== 'getIndex') {
$route = str_replace('..', '.', $prefix . '.' . Str::snake($action));
Route::$type($url, array('as' => $route, 'uses' => $controller_route));
}
}
}
};
}
