SqlServerParser.php does not comply with psr-4 autoloading standard in Crestapps - php

Trying to require CrestApps in a newly created Laravel project, gives me the following msg:
Class CrestApps\CodeGenerator\DatabaseParser\SqlServerParser located in C:/xampp/htdocs/cn/vendor/crestapps/laravel-code-generator/src\DatabaseParsers\SqlServerParser.php does not comply with psr-4 autoloading standard. Skipping.
Composer ver 2.0.7
CrestApps ver 2.4
Laravel installer 4.1.1
Composer.json file:
{
"name": "laravel/laravel",
"type": "project",
"description": "The Laravel Framework.",
"keywords": [
"framework",
"laravel"
],
"license": "MIT",
"require": {
"php": "^7.3|^8.0",
"fideloper/proxy": "^4.4",
"fruitcake/laravel-cors": "^2.0",
"guzzlehttp/guzzle": "^7.0.1",
"laravel/framework": "^8.12",
"laravel/tinker": "^2.5"
},
"require-dev": {
"crestapps/laravel-code-generator": "^2.4",
"facade/ignition": "^2.5",
"fakerphp/faker": "^1.9.1",
"mockery/mockery": "^1.4.2",
"nunomaduro/collision": "^5.0",
"phpunit/phpunit": "^9.3.3"
},
"config": {
"optimize-autoloader": true,
"preferred-install": "dist",
"sort-packages": true
},
"extra": {
"laravel": {
"dont-discover": []
}
},
"autoload": {
"psr-4": {
"App\\": "app/",
"Database\\Factories\\": "database/factories/",
"Database\\Seeders\\": "database/seeders/"
}
},
"autoload-dev": {
"psr-4": {
"Tests\\": "tests/"
}
},
"minimum-stability": "dev",
"prefer-stable": true,
"scripts": {
"post-autoload-dump": [
"Illuminate\\Foundation\\ComposerScripts::postAutoloadDump",
"#php artisan package:discover --ansi"
],
"post-root-package-install": [
"#php -r \"file_exists('.env') || copy('.env.example', '.env');\""
],
"post-create-project-cmd": [
"#php artisan key:generate --ansi"
]
}
}
SqlServerParser.php file:
<?php
namespace CrestApps\CodeGenerator\DatabaseParser;
use App;
use CrestApps\CodeGenerator\Models\Field;
use CrestApps\CodeGenerator\Models\FieldOptimizer;
use CrestApps\CodeGenerator\Support\DatabaseParser\ParserBase;
use DB;
use Exception;
class SqlServerParser extends ParserBase
{
/**
* The table name.
*
* #var array
*/
protected $tableName;
/**
* The databasename
*
* #var array
*/
protected $databaseName;
/**
* The locale value
*
* #var array
*/
protected $locale;
/**
* The final fields.
*
* #var array
*/
protected $fields;
/**
* Creates a new field instance.
*
* #param string $tableName
* #param string $databaseName
*
* #return void
*/
public function __construct($tableName, $databaseName)
{
$this->tableName = $tableName;
$this->databaseName = $databaseName;
$this->locale = App::getLocale();
}
/**
* Gets the final fields.
*
* #return array
*/
public function getFields()
{
if (is_null($this->fields)) {
$columns = $this->getColumn();
if (empty($columns)) {
throw new Exception('The table ' . $this->tableName . ' was not found in the ' . $this->databaseName . ' database.');
}
$this->fields = $this->transfer($columns);
}
return $this->fields;
}
/**
* Gets column meta info from the information schema.
*
* #return array
*/
protected function getColumn()
{
return DB::select(
'SELECT
c.COLUMN_NAME
,c.COLUMN_DEFAULT
,c.IS_NULLABLE
,c.DATA_TYPE
,c.CHARACTER_MAXIMUM_LENGTH
,pk.CONSTRAINT_TYPE AS EXTRA
FROM INFORMATION_SCHEMA.COLUMNS AS c
LEFT JOIN (
SELECT ku.TABLE_CATALOG,ku.TABLE_SCHEMA,ku.TABLE_NAME,ku.COLUMN_NAME, tc.CONSTRAINT_TYPE
FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS AS tc
INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS ku ON tc.CONSTRAINT_NAME = ku.CONSTRAINT_NAME
) AS pk ON c.TABLE_CATALOG = pk.TABLE_CATALOG
AND c.TABLE_SCHEMA = pk.TABLE_SCHEMA
AND c.TABLE_NAME = pk.TABLE_NAME
AND c.COLUMN_NAME = pk.COLUMN_NAME
WHERE c.TABLE_NAME = ? AND c.TABLE_CATALOG = ? ',
[$this->tableName, $this->databaseName]
);
}
/**
* Gets array of field after transfering each column meta into field.
*
* #param array $columns
*
* #return array
*/
protected function transfer(array $columns)
{
$fields = [];
foreach ($columns as $column) {
$field = new Field($column->COLUMN_NAME);
$this->setIsNullable($field, $column->IS_NULLABLE)
->setMaxLength($field, $column->CHARACTER_MAXIMUM_LENGTH)
->setDefault($field, $column->COLUMN_DEFAULT)
->setDataType($field, $column->DATA_TYPE)
->setKey($field, $column->COLUMN_KEY, $column->EXTRA)
->setLabel($field, $column->COLUMN_NAME)
->setHtmlType($field, $column->DATA_TYPE);
$optimizer = new FieldOptimizer($field);
$fields[] = $optimizer->optimize()->getField();
}
return $fields;
}
/**
* Set the unsiged flag for a given field.
*
* #param CrestApps\CodeGenerator\Models\Field $field
* #param string $type
*
* #return $this
*/
protected function setUnsigned(Field &$field, $type)
{
if (strpos($type, 'unsigned') !== false) {
$field->isUnsigned = true;
$field->validationRules[] = sprintf('min:%s', 0);
}
return $this;
}
/**
* Set the html type for a given field.
*
* #param CrestApps\CodeGenerator\Models\Field $field
* #param string $type
*
* #return $this
*/
protected function setHtmlType(Field &$field, $type)
{
$map = $this->getMap();
if (array_key_exists($type, $map)) {
$field->htmlType = $map[$type];
}
return $this;
}
/**
* Set the data type for a given field.
*
* #param CrestApps\CodeGenerator\Models\Field $field
* #param string $type
*
* #return $this
*/
protected function setDataType(Field &$field, $type)
{
$map = $this->dataTypeMap();
if (array_key_exists($type, $map)) {
$field->dataType = $map[$type];
}
return $this;
}
/**
* Set the nullable for a given field.
*
* #param CrestApps\CodeGenerator\Models\Field $field
* #param string $nullable
*
* #return $this
*/
protected function setIsNullable(Field &$field, $nullable)
{
$field->isNullable = (strtoupper($nullable) == 'YES');
return $this;
}
/**
* Set the max length for a given field.
*
* #param CrestApps\CodeGenerator\Models\Field $field
* #param string $length
*
* #return $this
*/
protected function setMaxLength(Field &$field, $length)
{
if (($value = intval($length)) > 0) {
$field->validationRules[] = sprintf('max:%s', $value);
$field->methodParams[] = $value;
}
return $this;
}
/**
* Set the default value for a given field.
*
* #param CrestApps\CodeGenerator\Models\Field $field
* #param string $default
*
* #return $this
*/
protected function setDefault(Field &$field, $default)
{
if (!empty($default)) {
$field->dataValue = $default;
}
return $this;
}
/**
* Set the labels for a given field.
*
* #param CrestApps\CodeGenerator\Models\Field $field
* #param string $name
*
* #return $this
*/
protected function setLabel(Field &$field, $name)
{
$field->addLabel($this->getLabelName($name), $this->tableName, true, $this->locale);
return $this;
}
/**
* Set the keys for a given field.
*
* #param CrestApps\CodeGenerator\Models\Field $field
* #param string $key
* #param string $extra
*
* #return $this
*/
protected function setKey(Field &$field, $key, $extra)
{
$key = strtoupper($key);
if ($key == 'PRIMARY KEY') {
$field->isPrimary = true;
}
if ($key == 'MUL') {
$field->isIndex = true;
}
if ($key == 'UNI') {
$field->isUnique = true;
}
if (strtolower($extra) == 'auto_increment') {
$field->isAutoIncrement = true;
}
return $this;
}
/**
* Gets a labe field's label from a given name.
*
* #return string
*/
protected function getLabelName($name)
{
return trim(ucwords(str_replace(['-', '_'], ' ', $name)));
}
/**
* Gets the eloquent method to html
*
* #return array
*/
protected function getMap()
{
return config('codegenerator.eloquent_type_to_html_type');
}
/**
* Gets the eloquent type to method collection
*
* #return array
*/
public function dataTypeMap()
{
return config('codegenerator.eloquent_type_to_method');
}
}

As per Composer version 2 changes regarding psr-4 autoloading standards, file SqlServerParser.php file had to be changed as follows:
line:
namespace CrestApps\CodeGenerator\DatabaseParser;
to be changed to:
namespace crestapps\laravelCodeGenerator\src\DatabaseParser;
Issue solved. Command "composer require crestapps/laravel-code-generator --dev" does not give any errors anymore, generating optimized autoload files successfully.

Related

Upgrade to Laravel 5.6 from 5.5 [duplicate]

I am trying to upgrade my Laravel 5.5 to 5.6. I have followed the instructions from the laravel website, yet I got this error:
Your requirements could not be resolved to an installable set of packages.
Problem 1
- The requested package laravel/framework 5.6.* is satisfiable by laravel/framework[5.6.x-dev] but these conflict with your requirements or minimum-stability.
So, I changed my composer.json file and added 2 lines: **"minimum-stability": "dev", "prefer-stable": true,** based on the first answer on this laracast discussion.
Everything seemed to be working just fine until I got another error:
Loading composer repositories with package information
Updating dependencies (including require-dev)
Package operations: 0 installs, 6 updates, 0 removals
- Updating sebastian/diff (2.0.1 => 3.0.0): Downloading (100%)
- Updating phpunit/phpunit-mock-objects (5.0.6 => 6.0.0): Downloading (100%) - Updating phpunit/php-timer (1.0.9 => 2.0.0): Downloading (100%)
- Updating phpunit/php-token-stream (2.0.2 => 3.0.0): Downloading (100%) - Updating phpunit/php-code-coverage (5.3.0 => 6.0.1): Downloading (100%) - Updating phpunit/phpunit (6.5.6 => 7.0.0): Downloading (100%)
Writing lock file
Generating optimized autoload files
> Illuminate\Foundation\ComposerScripts::postAutoloadDump
> #php artisan package:discover
In trustedproxy.php line 66:
Undefined class constant 'HEADER_CLIENT_IP'
Script #php artisan package:discover handling the post-autoload-dump event returned with error code 1
The problem on line 66 is Illuminate\Http\Request::HEADER_CLIENT_IP => 'X_FORWARDED_FOR',.
I have searched other posts on stackoverflow but still no luck. The last thing I tried was composer selfupdate and composer global update which was mentioned on the post composer dump-autoload not recognized command
Also, I cannot remove "minimum-stability": "dev","prefer-stable": true because if I do, then I will get the following error:
- Installation request for laravel/framework 5.6.* -> satisfiable by laravel/framework[5.6.x-dev].
- Removal request for laravel/framework == 5.6.9999999.9999999-dev
I have attached my composer.json file and trustedproxy.php respectively. Any help will be highly appreciated.
{
"name": "laravel/laravel",
"description": "The Laravel Framework.",
"minimum-stability": "dev",
"prefer-stable": true,
"keywords": ["framework", "laravel"],
"license": "MIT",
"type": "project",
"require": {
"php": ">=7.1.3",
"fideloper/proxy": "~3.3",
"laravel/framework": "5.6.*",
"laravel/tinker": "~1.0"
},
"require-dev": {
"filp/whoops": "~2.0",
"fzaninotto/faker": "~1.4",
"mockery/mockery": "~1.0",
"phpunit/phpunit": "~7.0",
"symfony/thanks": "^1.0"
},
"autoload": {
"classmap": [
"database/seeds",
"database/factories"
],
"psr-4": {
"App\\": "app/"
}
},
"autoload-dev": {
"psr-4": {
"Tests\\": "tests/"
}
},
"extra": {
"laravel": {
"dont-discover": [
]
}
},
"scripts": {
"post-root-package-install": [
"#php -r \"file_exists('.env') || copy('.env.example', '.env');\""
],
"post-create-project-cmd": [
"#php artisan key:generate"
],
"post-autoload-dump": [
"Illuminate\\Foundation\\ComposerScripts::postAutoloadDump",
"#php artisan package:discover"
]
},
"config": {
"preferred-install": "dist",
"sort-packages": true,
"optimize-autoloader": true
}
}
trustedproxy.php (error in line 66--> Illuminate\Http\Request::HEADER_CLIENT_IP => 'X_FORWARDED_FOR',)
<?php
return [
/*
* Set trusted proxy IP addresses.
*
* Both IPv4 and IPv6 addresses are
* supported, along with CIDR notation.
*
* The "*" character is syntactic sugar
* within TrustedProxy to trust any proxy
* that connects directly to your server,
* a requirement when you cannot know the address
* of your proxy (e.g. if using Rackspace balancers).
*
* The "**" character is syntactic sugar within
* TrustedProxy to trust not just any proxy that
* connects directly to your server, but also
* proxies that connect to those proxies, and all
* the way back until you reach the original source
* IP. It will mean that $request->getClientIp()
* always gets the originating client IP, no matter
* how many proxies that client's request has
* subsequently passed through.
*/
'proxies' => [
'192.168.1.10',
],
/*
* Or, to trust all proxies that connect
* directly to your server, uncomment this:
*/
# 'proxies' => '*',
/*
* Or, to trust ALL proxies, including those that
* are in a chain of forwarding, uncomment this:
*/
# 'proxies' => '**',
/*
* Default Header Names
*
* Change these if the proxy does
* not send the default header names.
*
* Note that headers such as X-Forwarded-For
* are transformed to HTTP_X_FORWARDED_FOR format.
*
* The following are Symfony defaults, found in
* \Symfony\Component\HttpFoundation\Request::$trustedHeaders
*
* You may optionally set headers to 'null' here if you'd like
* for them to be considered untrusted instead. Ex:
*
* Illuminate\Http\Request::HEADER_CLIENT_HOST => null,
*
* WARNING: If you're using AWS Elastic Load Balancing or Heroku,
* the FORWARDED and X_FORWARDED_HOST headers should be set to null
* as they are currently unsupported there.
*/
'headers' => [
(defined('Illuminate\Http\Request::HEADER_FORWARDED') ? Illuminate\Http\Request::HEADER_FORWARDED : 'forwarded') => 'FORWARDED',
Illuminate\Http\Request::HEADER_CLIENT_IP => 'X_FORWARDED_FOR',
Illuminate\Http\Request::HEADER_CLIENT_HOST => 'X_FORWARDED_HOST',
Illuminate\Http\Request::HEADER_CLIENT_PROTO => 'X_FORWARDED_PROTO',
Illuminate\Http\Request::HEADER_CLIENT_PORT => 'X_FORWARDED_PORT',
]
];
Illuminate\Http\Request file:
<?php
namespace Illuminate\Http;
use Closure;
use ArrayAccess;
use RuntimeException;
use Illuminate\Support\Arr;
use Illuminate\Support\Str;
use Illuminate\Support\Traits\Macroable;
use Illuminate\Contracts\Support\Arrayable;
use Symfony\Component\HttpFoundation\ParameterBag;
use Symfony\Component\HttpFoundation\Request as SymfonyRequest;
class Request extends SymfonyRequest implements Arrayable, ArrayAccess
{
use Concerns\InteractsWithContentTypes,
Concerns\InteractsWithFlashData,
Concerns\InteractsWithInput,
Macroable;
/**
* The decoded JSON content for the request.
*
* #var \Symfony\Component\HttpFoundation\ParameterBag|null
*/
protected $json;
/**
* All of the converted files for the request.
*
* #var array
*/
protected $convertedFiles;
/**
* The user resolver callback.
*
* #var \Closure
*/
protected $userResolver;
/**
* The route resolver callback.
*
* #var \Closure
*/
protected $routeResolver;
/**
* Create a new Illuminate HTTP request from server variables.
*
* #return static
*/
public static function capture()
{
static::enableHttpMethodParameterOverride();
return static::createFromBase(SymfonyRequest::createFromGlobals());
}
/**
* Return the Request instance.
*
* #return $this
*/
public function instance()
{
return $this;
}
/**
* Get the request method.
*
* #return string
*/
public function method()
{
return $this->getMethod();
}
/**
* Get the root URL for the application.
*
* #return string
*/
public function root()
{
return rtrim($this->getSchemeAndHttpHost().$this->getBaseUrl(), '/');
}
/**
* Get the URL (no query string) for the request.
*
* #return string
*/
public function url()
{
return rtrim(preg_replace('/\?.*/', '', $this->getUri()), '/');
}
/**
* Get the full URL for the request.
*
* #return string
*/
public function fullUrl()
{
$query = $this->getQueryString();
$question = $this->getBaseUrl().$this->getPathInfo() == '/' ? '/?' : '?';
return $query ? $this->url().$question.$query : $this->url();
}
/**
* Get the full URL for the request with the added query string parameters.
*
* #param array $query
* #return string
*/
public function fullUrlWithQuery(array $query)
{
$question = $this->getBaseUrl().$this->getPathInfo() == '/' ? '/?' : '?';
return count($this->query()) > 0
? $this->url().$question.http_build_query(array_merge($this->query(), $query))
: $this->fullUrl().$question.http_build_query($query);
}
/**
* Get the current path info for the request.
*
* #return string
*/
public function path()
{
$pattern = trim($this->getPathInfo(), '/');
return $pattern == '' ? '/' : $pattern;
}
/**
* Get the current decoded path info for the request.
*
* #return string
*/
public function decodedPath()
{
return rawurldecode($this->path());
}
/**
* Get a segment from the URI (1 based index).
*
* #param int $index
* #param string|null $default
* #return string|null
*/
public function segment($index, $default = null)
{
return Arr::get($this->segments(), $index - 1, $default);
}
/**
* Get all of the segments for the request path.
*
* #return array
*/
public function segments()
{
$segments = explode('/', $this->decodedPath());
return array_values(array_filter($segments, function ($value) {
return $value !== '';
}));
}
/**
* Determine if the current request URI matches a pattern.
*
* #param dynamic $patterns
* #return bool
*/
public function is(...$patterns)
{
foreach ($patterns as $pattern) {
if (Str::is($pattern, $this->decodedPath())) {
return true;
}
}
return false;
}
/**
* Determine if the route name matches a given pattern.
*
* #param dynamic $patterns
* #return bool
*/
public function routeIs(...$patterns)
{
return $this->route() && $this->route()->named(...$patterns);
}
/**
* Determine if the current request URL and query string matches a pattern.
*
* #param dynamic $patterns
* #return bool
*/
public function fullUrlIs(...$patterns)
{
$url = $this->fullUrl();
foreach ($patterns as $pattern) {
if (Str::is($pattern, $url)) {
return true;
}
}
return false;
}
/**
* Determine if the request is the result of an AJAX call.
*
* #return bool
*/
public function ajax()
{
return $this->isXmlHttpRequest();
}
/**
* Determine if the request is the result of an PJAX call.
*
* #return bool
*/
public function pjax()
{
return $this->headers->get('X-PJAX') == true;
}
/**
* Determine if the request is over HTTPS.
*
* #return bool
*/
public function secure()
{
return $this->isSecure();
}
/**
* Get the client IP address.
*
* #return string
*/
public function ip()
{
return $this->getClientIp();
}
/**
* Get the client IP addresses.
*
* #return array
*/
public function ips()
{
return $this->getClientIps();
}
/**
* Get the client user agent.
*
* #return string
*/
public function userAgent()
{
return $this->headers->get('User-Agent');
}
/**
* Merge new input into the current request's input array.
*
* #param array $input
* #return \Illuminate\Http\Request
*/
public function merge(array $input)
{
$this->getInputSource()->add($input);
return $this;
}
/**
* Replace the input for the current request.
*
* #param array $input
* #return \Illuminate\Http\Request
*/
public function replace(array $input)
{
$this->getInputSource()->replace($input);
return $this;
}
/**
* Get the JSON payload for the request.
*
* #param string $key
* #param mixed $default
* #return \Symfony\Component\HttpFoundation\ParameterBag|mixed
*/
public function json($key = null, $default = null)
{
if (! isset($this->json)) {
$this->json = new ParameterBag((array) json_decode($this->getContent(), true));
}
if (is_null($key)) {
return $this->json;
}
return data_get($this->json->all(), $key, $default);
}
/**
* Get the input source for the request.
*
* #return \Symfony\Component\HttpFoundation\ParameterBag
*/
protected function getInputSource()
{
if ($this->isJson()) {
return $this->json();
}
return $this->getRealMethod() == 'GET' ? $this->query : $this->request;
}
/**
* Create an Illuminate request from a Symfony instance.
*
* #param \Symfony\Component\HttpFoundation\Request $request
* #return \Illuminate\Http\Request
*/
public static function createFromBase(SymfonyRequest $request)
{
if ($request instanceof static) {
return $request;
}
$content = $request->content;
$request = (new static)->duplicate(
$request->query->all(), $request->request->all(), $request->attributes->all(),
$request->cookies->all(), $request->files->all(), $request->server->all()
);
$request->content = $content;
$request->request = $request->getInputSource();
return $request;
}
/**
* {#inheritdoc}
*/
public function duplicate(array $query = null, array $request = null, array $attributes = null, array $cookies = null, array $files = null, array $server = null)
{
return parent::duplicate($query, $request, $attributes, $cookies, $this->filterFiles($files), $server);
}
/**
* Filter the given array of files, removing any empty values.
*
* #param mixed $files
* #return mixed
*/
protected function filterFiles($files)
{
if (! $files) {
return;
}
foreach ($files as $key => $file) {
if (is_array($file)) {
$files[$key] = $this->filterFiles($files[$key]);
}
if (empty($files[$key])) {
unset($files[$key]);
}
}
return $files;
}
/**
* Get the session associated with the request.
*
* #return \Illuminate\Session\Store
*
* #throws \RuntimeException
*/
public function session()
{
if (! $this->hasSession()) {
throw new RuntimeException('Session store not set on request.');
}
return $this->session;
}
/**
* Get the session associated with the request.
*
* #return \Illuminate\Session\Store|null
*/
public function getSession()
{
return $this->session;
}
/**
* Set the session instance on the request.
*
* #param \Illuminate\Contracts\Session\Session $session
* #return void
*/
public function setLaravelSession($session)
{
$this->session = $session;
}
/**
* Get the user making the request.
*
* #param string|null $guard
* #return mixed
*/
public function user($guard = null)
{
return call_user_func($this->getUserResolver(), $guard);
}
/**
* Get the route handling the request.
*
* #param string|null $param
*
* #return \Illuminate\Routing\Route|object|string
*/
public function route($param = null)
{
$route = call_user_func($this->getRouteResolver());
if (is_null($route) || is_null($param)) {
return $route;
}
return $route->parameter($param);
}
/**
* Get a unique fingerprint for the request / route / IP address.
*
* #return string
*
* #throws \RuntimeException
*/
public function fingerprint()
{
if (! $route = $this->route()) {
throw new RuntimeException('Unable to generate fingerprint. Route unavailable.');
}
return sha1(implode('|', array_merge(
$route->methods(), [$route->getDomain(), $route->uri(), $this->ip()]
)));
}
/**
* Set the JSON payload for the request.
*
* #param \Symfony\Component\HttpFoundation\ParameterBag $json
* #return $this
*/
public function setJson($json)
{
$this->json = $json;
return $this;
}
/**
* Get the user resolver callback.
*
* #return \Closure
*/
public function getUserResolver()
{
return $this->userResolver ?: function () {
//
};
}
/**
* Set the user resolver callback.
*
* #param \Closure $callback
* #return $this
*/
public function setUserResolver(Closure $callback)
{
$this->userResolver = $callback;
return $this;
}
/**
* Get the route resolver callback.
*
* #return \Closure
*/
public function getRouteResolver()
{
return $this->routeResolver ?: function () {
//
};
}
/**
* Set the route resolver callback.
*
* #param \Closure $callback
* #return $this
*/
public function setRouteResolver(Closure $callback)
{
$this->routeResolver = $callback;
return $this;
}
/**
* Get all of the input and files for the request.
*
* #return array
*/
public function toArray()
{
return $this->all();
}
/**
* Determine if the given offset exists.
*
* #param string $offset
* #return bool
*/
public function offsetExists($offset)
{
return array_key_exists(
$offset, $this->all() + $this->route()->parameters()
);
}
/**
* Get the value at the given offset.
*
* #param string $offset
* #return mixed
*/
public function offsetGet($offset)
{
return $this->__get($offset);
}
/**
* Set the value at the given offset.
*
* #param string $offset
* #param mixed $value
* #return void
*/
public function offsetSet($offset, $value)
{
$this->getInputSource()->set($offset, $value);
}
/**
* Remove the value at the given offset.
*
* #param string $offset
* #return void
*/
public function offsetUnset($offset)
{
$this->getInputSource()->remove($offset);
}
/**
* Check if an input element is set on the request.
*
* #param string $key
* #return bool
*/
public function __isset($key)
{
return ! is_null($this->__get($key));
}
/**
* Get an input element from the request.
*
* #param string $key
* #return mixed
*/
public function __get($key)
{
if (array_key_exists($key, $this->all())) {
return data_get($this->all(), $key);
}
return $this->route($key);
}
}
Thanks
I did this and it works perfectly.
1. composer.json:
From:
"require": {
"php": ">=7.0.0",
"fideloper/proxy": "~3.3",
"laravel/framework": "5.5.*",
"laravel/tinker": "~1.0"
},
To:
"require": {
"php": ">=7.1.3",
"fideloper/proxy": "~4.0",
"laravel/framework": "5.6.*",
"laravel/tinker": "~1.0"
},
2. Replace app\Http\Middleware\TrustedProxies.php file with contents below:
<?php
namespace App\Http\Middleware;
use Illuminate\Http\Request;
use Fideloper\Proxy\TrustProxies as Middleware;
class TrustProxies extends Middleware
{
/**
* The trusted proxies for this application.
*
* #var array
*/
protected $proxies;
/**
* The headers that should be used to detect proxies.
*
* #var string
*/
protected $headers = Request::HEADER_X_FORWARDED_ALL;
}
3. composer update
Laravel's Request object extends Symfony's Request object. Laravel 5.5 depends on Symfony 3, which has that constant. Laravel 5.6 depends on Symfony 4, which does not have that constant.
Based on your trusted proxies configuration, it looks like you're using the trusted proxies package "outside" of Laravel. Laravel brought the trusted proxies package inside the framework in 5.5, and created a dedicated \App\Http\Middleware\TrustProxies middleware for you to use.
I would suggest moving to use the middleware and configuring it as described in the Laravel documentation. This will help prevent this type of compatibility issue in the future.
To make the switch:
In app/Http/Kernel.php, if \Fideloper\Proxy\TrustProxies::class is in your $middleware array, remove it. If \App\Http\Middleware\TrustProxies::class is not in your $middleware array, add it.
Open your app/Http/Middleware/TrustProxies.php file and update it with your proxies.
Delete your config/trustedproxy.php file.
Remove Fideloper\Proxy\TrustedProxyServiceProvider::class from your providers array in config/app.php.
Update your composer.json file to use "fideloper/proxy": "~4.0". Run composer update fideloper/proxy to update the package.
I have updated from 5.5 to 5.6
composer.json
"minimum-stability":"dev",
"prefer-stable": true,
This will install latest Laravel packages, then there will be issue with TrustedProxies.
Install the latest proxy version for Laravel 5.6.
Please use tag 4.0+ for Laravel 5.6:
composer require fideloper/proxy:~4.0
More details
First install Laravel 5.6 i faced this error as well.
Just follow the few steps below will fix it:
Make sure your file composer.json requirement has:
"require": {
"php": "^7.1.3",
"fideloper/proxy": "^4.0",
},
Then try composer update to make sure your composer is up-to-date
Finally run: composer require fideloper/proxy:~4.0
Done!
To anyone who tried upgrading directly from laravel 5.5 to 5.7, and got this problem too, remove the trustedproxy.php file from app->config->trustedproxy.php.
Hopes that helps someone.
Just need to Change fideloper/proxy in composer.json file:-
Your composer.json file now:-
"fideloper/proxy": "~3.3",
Change it to ^4.0 somthing like this:-
"fideloper/proxy": "^4.0",
After that you need to run update composer that's it.
composer update
Your problem comes from your use of the library TrustedProxy.
It uses Symfony's HEADER_CLIENT_IP constant which was deprecated with Symfony 3.3 and completely removed in Symfony 4.0.
Since Laravel 5.6 has updated to use Symfony 4 components, this will no longer work.
The way to solve it is to do what patricus suggested and use Laravel's TrustProxies middleware.
I did the following things and got my project to run on Laravel 5.6-dev:
Followed what patricus
suggested
Changed fideloper/proxy to "~4.0", and added "minimum-stability":
"dev", "prefer-stable": true at the end of my composer.json file.
Replace app\Http\Middleware\TrustedProxies.php by:
<?php
namespace App\Http\Middleware;
use Illuminate\Http\Request;
use Fideloper\Proxy\TrustProxies as Middleware;
class TrustProxies extends Middleware
{
protected $proxies;
protected $headers = Request::HEADER_X_FORWARDED_ALL;
}
Replace config\trustedproxy.php by:
<?php
return [
'proxies' => null,
'headers' => Illuminate\Http\Request::HEADER_X_FORWARDED_ALL,
];
None of the suggestions here worked for me for some reason. I am using quickadmin panel and various dependencies which might have something to do with it.
What finally worked was removing laravel/dusk, then updating to "fideloper/proxy": "~4.0", on it's own. Then updating laravel/framework to 5.6, then reinstalling dusk.
I did not need:
"minimum-stability":"dev",
"prefer-stable": true,
Maybe that was fixed with recent updates.
Faced the same issue and got a number of guidelines to resolve this. Unfortunately none of those worked or me. Actually there is no additional step or tasks needed to be addressed to fix this issue.
Just follow the official upgrade guide from https://laravel.com/docs/5.6/upgrade and along with that remove the trustedproxy config file located at config/trustedproxy.php
Had the same issue in Laravel 5.7. You may add TELESCOPE_ENABLED=false in your .env or .env.dusk.local :Source

DataFixture aren't saved using nelmio/alice ( sf 3.3 with flex)

Hello I'm using flex to work with Symfony for learning purpose. After I installed a few recipes and I want to add the nelmio/alice for generating fake data for doctrine fixtures but after I load the fixtures no data is saved into mysql. Any ideas what did i do wrong?
<?php
namespace App\DataFixtures\ORM;
use Doctrine\Bundle\FixturesBundle\Fixture;
use Doctrine\Common\Persistence\ObjectManager;
use Nelmio\Alice\Loader\NativeLoader;
class LoadFixtures extends Fixture
{
/**
* Load data fixtures with the passed EntityManager
*
* #param ObjectManager $manager
*/
public function load(ObjectManager $manager)
{
$loader = new NativeLoader();
$obj = $loader->loadFile(__DIR__ . 'fixtures.yml');
}
fixtures.yml:
App\Entity\BaseUser:
user{1..10}:
email: <email()>
BaseUser entity
<?php
namespace App\Entity;
use Symfony\Component\Security\Core\User\AdvancedUserInterface;
use Doctrine\ORM\Mapping as ORM;
/**
* Class BaseUser
* #package App\Entity
* #ORM\Entity
* #ORM\Table()
*/
class BaseUser implements AdvancedUserInterface
{
/**
* #ORM\Id
* #ORM\GeneratedValue(strategy="AUTO")
* #ORM\Column(type="integer")
*/
private $id;
/**
* #ORM\Column(type="string", unique=true)
*/
private $email;
/**
* #return mixed
*/
public function getId()
{
return $this->id;
}
/**
* #param mixed $id
* #return BaseUser
*/
public function setId($id)
{
$this->id = $id;
return $this;
}
/**
* #return mixed
*/
public function getEmail()
{
return $this->email;
}
/**
* #param mixed $email
* #return BaseUser
*/
public function setEmail($email)
{
$this->email = $email;
return $this;
}
/**
* Checks whether the user's account has expired.
*
* Internally, if this method returns false, the authentication system
* will throw an AccountExpiredException and prevent login.
*
* #return bool true if the user's account is non expired, false otherwise
*
* #see AccountExpiredException
*/
public function isAccountNonExpired()
{
// TODO: Implement isAccountNonExpired() method.
}
/**
* Checks whether the user is locked.
*
* Internally, if this method returns false, the authentication system
* will throw a LockedException and prevent login.
*
* #return bool true if the user is not locked, false otherwise
*
* #see LockedException
*/
public function isAccountNonLocked()
{
// TODO: Implement isAccountNonLocked() method.
}
/**
* Checks whether the user's credentials (password) has expired.
*
* Internally, if this method returns false, the authentication system
* will throw a CredentialsExpiredException and prevent login.
*
* #return bool true if the user's credentials are non expired, false otherwise
*
* #see CredentialsExpiredException
*/
public function isCredentialsNonExpired()
{
// TODO: Implement isCredentialsNonExpired() method.
}
/**
* Checks whether the user is enabled.
*
* Internally, if this method returns false, the authentication system
* will throw a DisabledException and prevent login.
*
* #return bool true if the user is enabled, false otherwise
*
* #see DisabledException
*/
public function isEnabled()
{
// TODO: Implement isEnabled() method.
}
/**
* Returns the roles granted to the user.
*
* <code>
* public function getRoles()
* {
* return array('ROLE_USER');
* }
* </code>
*
* Alternatively, the roles might be stored on a ``roles`` property,
* and populated in any number of different ways when the user object
* is created.
*
* #return (Role|string)[] The user roles
*/
public function getRoles()
{
return ['ROLE_USER'];
}
/**
* Returns the password used to authenticate the user.
*
* This should be the encoded password. On authentication, a plain-text
* password will be salted, encoded, and then compared to this value.
*
* #return string The password
*/
public function getPassword()
{
// TODO: Implement getPassword() method.
}
/**
* Returns the salt that was originally used to encode the password.
*
* This can return null if the password was not encoded using a salt.
*
* #return string|null The salt
*/
public function getSalt()
{
// TODO: Implement getSalt() method.
}
/**
* Returns the username used to authenticate the user.
*
* #return string The username
*/
public function getUsername()
{
return $this->email;
}
/**
* Removes sensitive data from the user.
*
* This is important if, at any given point, sensitive information like
* the plain-text password is stored on this object.
*/
public function eraseCredentials()
{
// TODO: Implement eraseCredentials() method.
}
}
bundles.php
<?php
return [
Symfony\Bundle\FrameworkBundle\FrameworkBundle::class => ['all' => true],
Doctrine\Bundle\DoctrineCacheBundle\DoctrineCacheBundle::class => ['all' => true],
Doctrine\Bundle\DoctrineBundle\DoctrineBundle::class => ['all' => true],
Doctrine\Bundle\MigrationsBundle\DoctrineMigrationsBundle::class => ['all' => true],
Sensio\Bundle\FrameworkExtraBundle\SensioFrameworkExtraBundle::class => ['all' => true],
Doctrine\Bundle\FixturesBundle\DoctrineFixturesBundle::class => ['dev' => true, 'test' => true],
Nelmio\Alice\Bridge\Symfony\NelmioAliceBundle::class => ['all' => true],
];
and in frameworky.yml i added this
nelmio_alice:
locale: 'en_US' # Default locale for the Faker Generator
seed: 6399 # Value used make sure Faker generates data consistently across
# runs, set to null to disable.
functions_blacklist: # Some Faker formatter may have the same name as PHP
- 'current' # native functions. PHP functions have the priority,
# so if you want to use a Faker formatter instead,
# blacklist this function here
loading_limit: 5 # Alice may do some recursion to resolve certain values.
# This parameter defines a limit which will stop the
# resolution once reached.
max_unique_values_retry: 150 # Maximum number of time Alice can try to
# generate a unique value before stopping and
# failing.
composer.yml
{
"type": "project",
"license": "proprietary",
"require": {
"php": "^7.0.8",
"doctrine/doctrine-fixtures-bundle": "^2.4",
"doctrine/doctrine-migrations-bundle": "^1.2",
"sensio/framework-extra-bundle": "^5.0",
"sensiolabs/security-checker": "^4.1",
"symfony/console": "^3.3",
"symfony/framework-bundle": "^3.3",
"symfony/orm-pack": "^1.0",
"symfony/security-core": "^3.3",
"symfony/yaml": "^3.3"
},
"require-dev": {
"nelmio/alice": "^3.1",
"symfony/dotenv": "^3.3",
"symfony/flex": "^1.0"
},
"config": {
"preferred-install": {
"*": "dist"
},
"sort-packages": true
},
"autoload": {
"psr-4": {
"App\\": "src/"
}
},
"autoload-dev": {
"psr-4": {
"App\\Tests\\": "tests/"
}
},
"scripts": {
"auto-scripts": {
"cache:clear": "symfony-cmd",
"assets:install --symlink --relative %PUBLIC_DIR%": "symfony-cmd",
"security-checker security:check": "script"
},
"post-install-cmd": [
"#auto-scripts"
],
"post-update-cmd": [
"#auto-scripts"
]
},
"conflict": {
"symfony/symfony": "*",
"symfony/twig-bundle": "<3.3",
"symfony/debug": "<3.3"
},
"extra": {
"symfony": {
"id": "01BX9RZX7RBK5CNHP741EVCXB5",
"allow-contrib": false
}
}
}
I was trying to follow the KNP Symfony video tutorial and got lost on Nelmio/Alice repo. Bogdan's answer worked for me.
You need to add Alice Data Fixtures repo.
After adding
Here's a quick guide for all of you who's also lost:
namespace AppBundle\DataFixtures\ORM;
use Doctrine\Common\DataFixtures\FixtureInterface;
use Doctrine\Common\Persistence\ObjectManager;
use Symfony\Bundle\FrameworkBundle\Controller\Controller;
class DataFixtures extends Controller implements FixtureInterface
{
public function load(ObjectManager $manager)
{
//File Path/s needs to be in array
$dummyFilePath =[__DIR__.'/DataFixtures.yml'];
//get fidry loader
$loader = $this->get('fidry_alice_data_fixtures.doctrine.loader');
//execute
$loader->load($dummyFilePath);
}
}
I solved the problem by installing theofidry/alice-data-fixtures since it seems nelmio/alice 3.x doesn't work the same as the older version. ( It doesn't takes care of the database query anymore ) .
LE:
Maybe it's my fault or not but since the official release of the sf 4 i had some problems with the loading part.
Here's a fix for anyone looking into
You need a service like this to load the fixtures
App\DataFixtures\ORM\DataFixtures:
arguments: ['#fidry_alice_data_fixtures.doctrine.purger_loader']
calls:
- [load, ['#doctrine.orm.entity_manager']]
tags: [doctrine.fixture.orm]
And in the method
$files = [
__DIR__ . '/fixtures.yml',
];
$this->loader->load($files);

How to inject a repository on another repository class in Laravel 5 (5.2)

Let's say I have two repositories (UserRepository, RoleRepository) that implements a contract (UserRepositoryInterface, RoleRepositoryInterface).
What I wanted to do is to inject RoleRepository into UserRepository's constructor method and I've been trying to make this work but I'm getting this error:
Target [App\Contracts\UserRepositoryInterface] is not instantiable while building [App\Http\Controllers\UserController].
Here's what I got so far,
composer.json
"require": {
"php": ">=5.5.9",
"laravel/framework": "5.2.*",
"tymon/jwt-auth": "^0.5.9",
"zizaco/entrust": "dev-laravel-5"
},
"require-dev": {
"fzaninotto/faker": "~1.4",
"mockery/mockery": "^0.9.4",
"phpunit/phpunit": "~4.0",
"symfony/css-selector": "2.8.*|3.0.*",
"symfony/dom-crawler": "2.8.*|3.0.*"
},
"autoload": {
"classmap": [
"database"
],
"psr-4": {
"App\\": "app/",
"App\\Models\\": "app/Models/",
"App\\Contracts\\": "app/Contracts/",
"App\\Repositories\\": "app/Repositories/"
}
},
"autoload-dev": {
"classmap": [
"tests/TestCase.php",
"tests/MockData.php"
]
}
config/app.php
'providers' => [
/*
* Laravel Framework Service Providers...
*/
...
/**
* Third-party Service Providers
*/
...
/*
* Application Service Providers...
*/
...
/**
* Custom Service Providers...
*/
App\Providers\RepositoryServiceProvider::class,
app/Providers/RepositoryServiceProvider.php
namespace App\Providers;
use Illuminate\Support\ServiceProvider;
class RepositoryServiceProvider extends ServiceProvider
{
public function register()
{
$models = [
'Role',
'User',
];
foreach ($models as $model) {
$this->app->bind(
"App\Contracts\\{$model}Interface",
"App\Repositories\\{$model}Repository"
);
}
}
}
app/Controllers/UserController.php
<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
use App\Http\Requests;
use App\Http\Controllers\Controller;
use App\Contracts\UserRepositoryInterface as UserRepository;
class UserController extends Controller
{
/**
* #var UserRepository
*/
private $repo;
/**
* Class constructor
*
* #param UserRepository $repo
*/
public function __construct(
UserRepository $repo
) {
$this->repo = $repo;
}
/**
* Store a newly created resource in storage.
*
* #param \Illuminate\Http\Request $request
*
* #return \Illuminate\Http\JsonResponse
*/
public function store(Request $request)
{
$data = $request->all();
$user = $this->repo->store($data);
return response()->json($user, 201);
}
/**
* Update the specified resource in storage.
*
* #param \Illuminate\Http\Request $request
* #param int $id
*
* #return \Illuminate\Http\JsonResponse
*/
public function update(Request $request, $id)
{
$data = $request->all();
$user = $this->repo->store($data, $id);
return response()->json($data, 200);
}
app/Contracts/RoleRepositoryInterface.php
<?php
namespace App\Contracts;
interface RoleRepositoryInterface
{
/**
* Attach role to user
*
* #param static $user
* #param string $roleName
*
* #return static
*/
public function role($user, $roleName);
}
app/Contracts/UserRepositoryInterface.php
<?php
namespace App\Contracts;
interface UserRepositoryInterface
{
/**
* Create new or update an existing user
*
* #param array $data
* #param int $id
*
* #return bool|int|array
*/
public function store(array $data, $id = null);
}
app/Repositories/RoleRepository.php
<?php
namespace App\Repositories;
use InvalidArgumentException;
use App\Contracts\RoleRepositoryInterface;
use App\Models\Role;
class RoleRepository extends Role implements RoleRepositoryInterface
{
/**
* Attach a role to user
*
* #param static $user
* #param string $roleName
*
* #return static
*
* #throws \InvalidArgumentException
*/
public function attachRole($user, $roleName)
{
if (!$user instanceof App\Models\User::class) {
throw new InvalidArgumentException("{$user} must be an instance of App\Models\User");
}
// find role
$role = $this->where('name', $roleName)->first();
// attach role to user
$user->attachRole($role);
return $user;
}
}
app/Repositories/UserRepository.php
<?php
namespace App\Repositories;
use App\Contracts\RoleRepositoryInterface as RoleRepository;
use App\Contracts\UserRepositoryInterface;
use App\Models\User;
class UserRepository extends User implements UserRepositoryInterface
{
/**
* #var RoleRepository
*/
private $roleRepo;
/**
* Class constructor
*
* #param RoleRepository $roleRepo
*/
public function __construct(RoleRepository $roleRepo)
{
$this->roleRepo = $roleRepo;
}
/**
* Create new or update an existing user
*
* #param array $data
* #param int $id
*
* #return bool|int|static
*/
public function store(array $data, $id = null)
{
if (is_null($id)) {
$user = $this->create($data);
$userWithRole = $this->roleRepo->attachRole($user, $data['role']);
return $user;
} else {
return $this->where('id', $id)
->update($data);
}
}
}
Any answers is greatly appreciated...
I think you have an error in your code, specifically in the RepositoryServiceProvider. It should be:
foreach ($models as $model) {
$this->app->bind(
"App\Contracts\\{$model}RepositoryInterface",
"App\Repositories\\{$model}Repository"
);
}
Note: the error is in the concatenation, you got "App\Contracts\\{$model}Interface", but it should be "App\Contracts\\{$model}RepositoryInterface"

Intervention laravel 5

I'm trying to install intervention. I run this command
composer require intervention/image
and composer.json is updated.
I add 'Image' => 'Intervention\Image\Facades\Image::class'in $aliases array and it's ok. Then i addIntervention\Image\ImageServiceProvider::class` in the $providers array and it didn't work.
This is what i obtain when type composer update
PHP Fatal error: Class 'Intervention\Image\ImageServiceProvider' not found in /home/vagrant/Code/laravel-basics/vendor/laravel/framework/src/Illuminate/Foundation/ProviderRepository.php on line 146
[Symfony\Component\Debug\Exception\FatalErrorException]
Class 'Intervention\Image\ImageServiceProvider' not found `
<?php
ProviderRepository.php
<?php
namespace Illuminate\Foundation;
use Illuminate\Filesystem\Filesystem;
use Illuminate\Contracts\Foundation\Application as ApplicationContract;
class ProviderRepository
{
/**
* The application implementation.
*
* #var \Illuminate\Contracts\Foundation\Application
*/
protected $app;
/**
* The filesystem instance.
*
* #var \Illuminate\Filesystem\Filesystem
*/
protected $files;
/**
* The path to the manifest file.
*
* #var string
*/
protected $manifestPath;
/**
* Create a new service repository instance.
*
* #param \Illuminate\Contracts\Foundation\Application $app
* #param \Illuminate\Filesystem\Filesystem $files
* #param string $manifestPath
* #return void
*/
public function __construct(ApplicationContract $app, Filesystem $files, $manifestPath)
{
$this->app = $app;
$this->files = $files;
$this->manifestPath = $manifestPath;
}
/**
* Register the application service providers.
*
* #param array $providers
* #return void
*/
public function load(array $providers)
{
$manifest = $this->loadManifest();
// First we will load the service manifest, which contains information on all
// service providers registered with the application and which services it
// provides. This is used to know which services are "deferred" loaders.
if ($this->shouldRecompile($manifest, $providers)) {
$manifest = $this->compileManifest($providers);
}
// Next, we will register events to load the providers for each of the events
// that it has requested. This allows the service provider to defer itself
// while still getting automatically loaded when a certain event occurs.
foreach ($manifest['when'] as $provider => $events) {
$this->registerLoadEvents($provider, $events);
}
// We will go ahead and register all of the eagerly loaded providers with the
// application so their services can be registered with the application as
// a provided service. Then we will set the deferred service list on it.
foreach ($manifest['eager'] as $provider) {
$this->app->register($this->createProvider($provider));
}
$this->app->setDeferredServices($manifest['deferred']);
}
/**
* Register the load events for the given provider.
*
* #param string $provider
* #param array $events
* #return void
*/
protected function registerLoadEvents($provider, array $events)
{
if (count($events) < 1) {
return;
}
$app = $this->app;
$app->make('events')->listen($events, function () use ($app, $provider) {
$app->register($provider);
});
}
/**
* Compile the application manifest file.
*
* #param array $providers
* #return array
*/
protected function compileManifest($providers)
{
// The service manifest should contain a list of all of the providers for
// the application so we can compare it on each request to the service
// and determine if the manifest should be recompiled or is current.
$manifest = $this->freshManifest($providers);
foreach ($providers as $provider) {
$instance = $this->createProvider($provider);
// When recompiling the service manifest, we will spin through each of the
// providers and check if it's a deferred provider or not. If so we'll
// add it's provided services to the manifest and note the provider.
if ($instance->isDeferred()) {
foreach ($instance->provides() as $service) {
$manifest['deferred'][$service] = $provider;
}
$manifest['when'][$provider] = $instance->when();
}
// If the service providers are not deferred, we will simply add it to an
// array of eagerly loaded providers that will get registered on every
// request to this application instead of "lazy" loading every time.
else {
$manifest['eager'][] = $provider;
}
}
return $this->writeManifest($manifest);
}
/**
* Create a new provider instance.
*
* #param string $provider
* #return \Illuminate\Support\ServiceProvider
*/
public function createProvider($provider)
{
return new $provider($this->app);
}
/**
* Determine if the manifest should be compiled.
*
* #param array $manifest
* #param array $providers
* #return bool
*/
public function shouldRecompile($manifest, $providers)
{
return is_null($manifest) || $manifest['providers'] != $providers;
}
/**
* Load the service provider manifest JSON file.
*
* #return array
*/
public function loadManifest()
{
// The service manifest is a file containing a JSON representation of every
// service provided by the application and whether its provider is using
// deferred loading or should be eagerly loaded on each request to us.
if ($this->files->exists($this->manifestPath)) {
$manifest = json_decode($this->files->get($this->manifestPath), true);
return array_merge(['when' => []], $manifest);
}
}
/**
* Write the service manifest file to disk.
*
* #param array $manifest
* #return array
*/
public function writeManifest($manifest)
{
$this->files->put(
$this->manifestPath, json_encode($manifest, JSON_PRETTY_PRINT)
);
return $manifest;
}
/**
* Create a fresh service manifest data structure.
*
* #param array $providers
* #return array
*/
protected function freshManifest(array $providers)
{
return ['providers' => $providers, 'eager' => [], 'deferred' => []];
}
}
composer.json
{
"name": "laravel/laravel",
"description": "The Laravel Framework.",
"keywords": ["framework", "laravel"],
"license": "MIT",
"type": "project",
"require": {
"php": ">=5.5.9",
"laravel/framework": "5.1.*",
"intervention/image": "dev-master"
},
"require-dev": {
"fzaninotto/faker": "~1.4",
"mockery/mockery": "0.9.*",
"phpunit/phpunit": "~4.0",
"phpspec/phpspec": "~2.1"
},
"autoload": {
"classmap": [
"database",
"app/Models"
],
"psr-4": {
"App\\": "app/"
}
},
"autoload-dev": {
"classmap": [
"tests/TestCase.php"
]
},
"scripts": {
"post-install-cmd": [
"php artisan clear-compiled",
"php artisan optimize"
],
"post-update-cmd": [
"php artisan clear-compiled",
"php artisan optimize"
],
"post-root-package-install": [
"php -r \"copy('.env.example', '.env');\""
],
"post-create-project-cmd": [
"php artisan key:generate"
]
},
"config": {
"preferred-install": "dist"
},
"require": {
"illuminate/html": "5.*"
},
"minimum-stability": "dev",
"prefer-stable": true
}
I would try removing ::class.
This setup works for me:
'providers' => [
'Intervention\Image\ImageServiceProvider',
],
'aliases' => [
'Image' => 'Intervention\Image\Facades\Image',
]
If you're using the PHP 5.5 ::class reference, then you shouldn't put it in quotes. Putting it in quotes makes it a string, and that's not what it is. It's just a static reference to the fully qualified class name.
So you either want to use this
'providers' => [
Intervention\Image\ImageServiceProvider::class,
],
'aliases' => [
'Image' => Intervention\Image\Facades\Image::class,
]
or this
'providers' => [
'Intervention\Image\ImageServiceProvider',
],
'aliases' => [
'Image' => 'Intervention\Image\Facades\Image',
]

Automatically map MySQL bit fields to bool properties

Consider that I got several models that store some flags using MySQL's bit field.
I know that it can easily be converted into bool by doing the follow:
$myBoolFlag = (ord($model->myFlag) == 1) ? true : false;
I'm looking for some way to make it map to a boolean property automatically.
Please someone tell me that there is an better way than creating setters and getters for every bit field in my project. I bet that Phalcon has some magic configuration in the DB service or something like this...
The way I have dealt with a similar issue is to create map arrays in each model and work with those. More specifically:
<?php
/**
* Model.php
*
* Model
*
* #author Nikos Dimopoulos <nikos#niden.net>
* #since 2012-12-12
* #category Library
*
*/
namespace NDN;
use \Phalcon\DI\FactoryDefault as PhDi;
use \Phalcon\Mvc\Model as PhModel;
class Model extends PhModel
{
private $meta = [];
/**
* Some init stuff
*/
public function initialize()
{
// Disable literals
$this->setup(['phqlLiterals' => false]);
}
/**
* Universal method caller. This checks the available methods based on
* the fields in the meta array and returns the relevant results
*
* #author Nikos Dimopoulos <nikos#niden.net>
* #since 2015-02-15
*
* #param string $function
* #param array|null $arguments
*
* #return mixed|void
* #throws \Exception
*/
public function __call($function, $arguments = null)
{
// $function is something like getId, setId, getName etc.
$metaFunction = substr($function, 3);
$field = $this->getMetaFunctionToField($metaFunction);
if ($field) {
$prefix = substr($function, 0, 3);
$fieldName = $field['field'];
switch ($prefix) {
case 'get':
/**
* Data manipulation here if needed
*/
$value = $this->getField($fieldName);
$value = $this->metaFieldValidate($field, $value);
return $value;
break;
case 'set':
/**
* Data manipulation here
*/
$value = $this->metaFieldValidate($field, $arguments);
$this->setField($field, $value);
break;
}
} else {
throw new \Exception('Function does not exist');
}
}
/**
* -------------------------------------------------------------------------
* PROTECTED METHODS
* -------------------------------------------------------------------------
*/
/**
* Gets a field from the model with the correct prefix
*
* #param $name
*
* #return mixed
*/
protected function getField($name)
{
return $this->$name;
}
/**
* Sets a field in the model
*
* #author Nikos Dimopoulos <nikos#niden.net>
* #since 2014-02-15
*
* #param string $field
* #param mixed $value
*/
protected function setField($field, $value)
{
$this->$field = $value;
}
/**
* Returns the DI container
*
* #author Nikos Dimopoulos <nikos#niden.net>
* #since 2014-02-22
*
* #return mixed
*/
public function getDI()
{
return PhDi::getDefault();
}
/**
* Accesses the internal array map to provide the field name from a function
*
* #author Nikos Dimopoulos <nikos#niden.net>
* #since 2014-02-27
*
* #param string $prefix The prefix of the table
* #param string $function The aliased function
*
* #return string The field name (i.e. tnt_id)
* bool False if not found
*/
public function getMetaFunctionToField($function)
{
if (array_key_exists($function, $this->meta)) {
return $this->meta[$function];
}
return false;
}
/**
* Validates a setter value based on each field's type
*
* #author Nikos Dimopoulos <nikos#niden.net>
* #since 2014-02-17
*
* #param string $field The field to check
* #param mixed $value The value of the field
*
* #return bool|int|string
*/
protected function metaFieldValidate($field, $value)
{
// Find the validator
$validator = $field['validator'];
switch ($validator)
{
case 'int':
$return = intval($value);
break;
case 'bit':
$return = (ord($value) == 1) ? true : false;
break;
case 'bool':
$return = (bool) $value;
break;
case 'decimal':
$return = (float) $value;
break;
case 'string':
$return = (string) $value;
break;
case 'datetime':
/**
* #todo check datetime validator
*/
$return = (string) $value;
break;
default:
$return = $value;
break;
}
return $return;
}
}
A sample User model looks like this
<?php
/**
* User.php
*
* User
*
* #author Nikos Dimopoulos <nikos#niden.net>
* #since 2014-03-08
* #category Models
*
*/
namespace NDN;
use \NDN\Model as NDNModel;
class Model extends NDNModel
{
public function initialize()
{
/**
* This is where I will set the field map
*
* The key of the array is the function name without
* the prefix. So for instance if you want getName()
* to return the user.name you use Name as the key
*/
$this->data = [
'Id' => [
'field' => 'user_id',
'validator' => 'int',
],
'Name' => [
'field' => 'user_name',
'validator' => 'int',
],
'IsMarried' => [
'field' => 'user_is_married',
'validator' => 'bit',
]
];
parent::initialize();
}
}
I've ended up by following the Nikolao's approach and implemented a base class for my models that can parse bit fields into more practical values. However, I designed it to not override the default mapping behavior. Something like that:
abstract class BaseModel extends Phalcon\Mvc\Model
{
public function explicitDataTypes()
{
//TODO: Suport relational data
$numargs = func_num_args();
if($numargs)
{
foreach (func_get_args() as $arg)
{
if(isset($this->$arg)) $this->$arg = $this->explicitDataType($arg)
}
}
else
{
foreach (get_object_vars($this) as $key => $value)
{
if($key[0] != '_') $this->$key = $this->explicitDataType($key)
}
}
}
public function explicitDataType($propertyName)
{
$value = $this->$propertyName;
if(is_numeric($value))
{
$locale = localeconv();
$separatorCount = substr_count($value, $locale['decimal_point']);
if($separatorCount == 0) $value = (int)$value;
elseif($separatorCount == 1) $value = (float)$value;
}
elseif(strlen($value) == 1 && ord($value) <= 1) $value = ord($value) == 1;
return $value;
}
}
Examples
class User extends BaseModel
{
protected $password;
public function afterFetch()
{
//Explicit data type for specific fields (e.g. var_dump($user->activated); //bool(true))
$this->explicitDataTypes('activated', 'deleted');
}
}
class Location extends BaseModel
{
public function afterFetch()
{
//Explicit data type for specific all fields (e.g. var_dump($location->distance); //float(12.3)
$this->explicitDataTypes();
}
}

Categories