/**
* @param WithInterface|DataInterface|ModelInterface $config
* @return mixed
*/
public function apply($config)
{
if (!($config instanceof WithInterface && $config instanceof DataInterface && $config instanceof ModelInterface)) {
return;
}
if ($config->with()->isEmpty()) {
return;
}
$this->config = $config;
$this->allowed = $config->with();
foreach ($this->allowed as $key => $value) {
if (is_numeric($key)) {
$this->allowed->forget($key)->put($value, '*');
}
}
foreach (explode('|', $config->data()->get('with', '')) as $with) {
$parts = explode(':', $with);
if (count($parts) == 0) {
continue;
}
if (!$this->allowed->has($parts[0])) {
continue;
}
$this->processWith($parts[0], isset($parts[1]) ? $parts[1] : '');
}
if (count($this->approved) > 0) {
$config->model($config->model()->with($this->approved));
}
}
/**
* @param string $key
*
* @return array
*/
protected function loadRules($key)
{
if (!$this->rules->has($key)) {
$this->rules->put($key, $this->loadRulesFromFile($key));
}
return $this->rules->get($key);
}
/**
* Get instance of type.
*
* @param string $name
* @param bool $fresh
* @return \GraphQL\Type\Definition\ObjectType
*/
public function instance($name, $fresh = false)
{
if (!$fresh && $this->instances->has($name)) {
return $this->instances->get($name);
}
$type = $this->getType($name)->resolve();
$instance = $type instanceof Model ? (new EloquentType($type, $name))->toType() : $type->toType();
$this->instances->put($name, $instance);
return $instance;
}
/**
* Add a new Item (or edit an existing item) to the Group
*
* @param string $name
* @param callable $callback
*
* @return Item
*/
public function item($name, Closure $callback = null)
{
if ($this->items->has($name)) {
$item = $this->items->get($name);
} else {
$item = $this->container->make('Maatwebsite\\Sidebar\\Item');
$item->name($name);
}
$this->call($callback, $item);
$this->addItem($item);
return $item;
}
/**
* @param $records
*
* @return mixed
*/
public function mutateRecords($records)
{
$_ignored = ['id', 'sortorder', 'updated_at', 'created_at'];
foreach ($records as $model) {
$toLoop = array_except($model->toArray(), $_ignored);
foreach ($toLoop as $k => $r) {
if ($this->attributes->has($k)) {
$model->{$k} = $this->attributes[$k]->getDisplayValue($model);
}
}
}
return $records;
}
/**
* Get instance of connection type.
*
* @param string $name
* @param string|null $parent
* @param bool $fresh
* @return \Nuwave\Lighthouse\Support\Definition\Fields\ConnectionField
*/
public function instance($name, $parent = null, $fresh = false)
{
$instanceName = $this->instanceName($name);
$typeName = $this->typeName($name);
if (!$fresh && $this->instances->has($instanceName)) {
return $this->instances->get($instanceName);
}
$key = $parent ? $parent . '.' . $instanceName : $instanceName;
$nodeType = $this->getSchema()->typeInstance($typeName);
$instance = $this->getInstance($name, $nodeType);
$this->instances->put($key, $instance);
return $instance;
}
/**
* @return void
*/
public function preInstall()
{
if ($this->extension->has('autoload')) {
$autoload = collect($this->extension->get('autoload'));
$autoload->has('classmap') && collect($autoload->get('classmap'))->each(function ($value) {
$path = str_replace($this->container->basePath() . '/', '', realpath($this->path . DIRECTORY_SEPARATOR . $value)) . '/';
if (!in_array($path, $this->backup['autoload']['classmap'])) {
$this->backup['autoload']['classmap'][] = $path;
}
});
$autoload->has('files') && collect($autoload->get('files'))->each(function ($value) {
$path = str_replace($this->container->basePath() . '/', '', realpath($this->path . DIRECTORY_SEPARATOR . $value));
if (!in_array($path, $this->backup['autoload']['files'])) {
$this->backup['autoload']['files'][] = $path;
}
});
$autoload->has('psr-0') && collect($autoload->get('psr-0'))->each(function ($value, $key) {
$path = str_replace($this->container->basePath() . '/', '', realpath($this->path . DIRECTORY_SEPARATOR . $value)) . '/';
$this->backup['autoload']['psr-0'][$key] = $path;
});
$autoload->has('psr-4') && collect($autoload->get('psr-4'))->each(function ($value, $key) {
$path = str_replace($this->container->basePath() . '/', '', realpath($this->path . DIRECTORY_SEPARATOR . $value)) . '/';
$this->backup['autoload']['psr-4'][$key] = $path;
});
}
if ($this->extension->has('require')) {
$require = collect($this->extension->get('require'));
$require->each(function ($version, $name) {
$this->backup['require'][$name] = $version;
});
}
}
/**
* Get single filter by key
*
* @param $key
* @param string $default_value Default value if key is not found
*
* @return mixed|string
*/
public function getFilter($key, $default_value = '')
{
if ($this->filters->has($key)) {
return $this->filters[$key];
}
return $default_value;
}
/**
* Parse parameters and return the altering classes
*
* @param mixed $parameters
* @return \Illuminate\Support\Collection
*/
public function parse($parameters)
{
// Fetch parameters. If the variable is an array nothing will happen.
// If it's a string, it will be tokenized and will return as an array.
$params = $this->getParameters($parameters);
$collection = new Collection();
foreach ($params as $token => $value) {
// create the manipulator
$manipulator = $this->createManipulator($token);
$className = get_class($manipulator);
// get the classname
if ($collection->has($className)) {
$manipulator = $collection->get($className);
}
// set values
if ($token === self::REQUEST_PARAM_WIDTH) {
$manipulator->setWidth($value);
} elseif ($token === self::REQUEST_PARAM_HEIGHT) {
$manipulator->setHeight($value);
}
// put in the colllection
$collection->put($className, $manipulator);
}
return $collection;
}
/**
* Returns the user throttles collection.
*
* @param \Cartalyst\Sentinel\Users\UserInterface $user
* @return \Illuminate\Support\Collection
*/
protected function getUserThrottles(UserInterface $user)
{
if (!$this->userThrottles->has($user->getUserId())) {
$this->userThrottles[$user->getUserId()] = $this->loadUserThrottles($user);
}
return $this->userThrottles[$user->getUserId()];
}
/**
* Get instance of edge type.
*
* @param string $name
* @param bool $fresh
* @param ObjectType|null $type
* @return \GraphQL\Type\Definition\ObjectType|null
*/
public function instance($name, $fresh = false, ObjectType $type = null)
{
$instanceName = $this->instanceName($name);
if (!$fresh && $this->instances->has($instanceName)) {
return $this->instances->get($instanceName);
}
if ($name instanceof ConnectionEdge) {
$instance = $this->createEdge($name);
$this->instances->put($instanceName, $instance);
return $instance;
} elseif ($type) {
$instance = $this->createInstance($name, $type);
$this->instances->put($name, $instance);
return $instance;
}
return null;
}
public function __call($name, $arguments)
{
$prefix = substr($name, 0, 3);
$property = snake_case(substr($name, 3));
if ($prefix === 'get' && $this->attributes->has($property)) {
return $this->get($property);
}
throw new \InvalidArgumentException();
}
/**
* @param TransactionJournal $entry
*/
public function addOrCreateIncome(TransactionJournal $entry)
{
$accountId = $entry->account_id;
if (!$this->incomes->has($accountId)) {
$newObject = new stdClass();
$newObject->amount = strval(round($entry->amount, 2));
$newObject->name = $entry->name;
$newObject->count = 1;
$newObject->id = $accountId;
$this->incomes->put($accountId, $newObject);
} else {
bcscale(2);
$existing = $this->incomes->get($accountId);
$existing->amount = bcadd($existing->amount, $entry->amount);
$existing->count++;
$this->incomes->put($accountId, $existing);
}
}
/**
* Removes Criteria, but only for the next call, resets to default afterwards
* Note that this does NOT work for specific criteria exclusively, it resets
* to default for ALL Criteria.
*
* In effect, this adds a NullCriteria to onceCriteria by key, disabling any criteria
* by that key in the normal criteria list.
*
* @param string $key
* @return $this
*/
public function removeCriteriaOnce($key)
{
// if not present in normal list, there is nothing to override
if (!$this->criteria->has($key)) {
return $this;
}
// override by key with Null-value
$this->onceCriteria->put($key, new NullCriteria());
return $this;
}
/**
* Mass-assign options for given fields.
* @param $array array column=>options
* @return $this
*/
public function setOptions($array)
{
foreach ($array as $field => $options) {
if (!$this->fields->has($field)) {
continue;
}
$this->getField($field)->options = $options;
}
return $this;
}
/**
* Ask the user what they would like to register with the application
*
* @return void
*/
public function whatWouldYouLikeToRegister()
{
$choices = $this->registrars->keys();
$choices[] = 'No more';
$registerType = $this->askWithCompletion('What would you like to register? (' . implode(', ', $choices->toArray()) . ')', $choices->toArray(), $choices->first());
if ($registerType === 'No more') {
foreach ($this->registrars as $registrar) {
$registrar->afterRegistration();
}
$this->updateEnvFile();
return;
}
if ($registerType == '' || !$this->registrars->has($registerType)) {
$this->error('Unable to register that. Please try again.');
$this->whatWouldYouLikeToRegister();
return;
}
$this->registrars->get($registerType)->register();
$this->whatWouldYouLikeToRegister();
}
/**
* Process the payload.
* @param Collection $payload
* @return Collection
*/
public function process($payload)
{
$series = $payload->pull('series');
$series->persist();
if ($payload->has('game')) {
$game = $payload->get('game');
$series->relatesToGame($game);
}
$payload->put('series', $series->model);
return $payload;
}
/**
* Fetch all the queues inside the 'queues' namespace with the delayed and
* reserved.
*
* @return \Illuminate\Support\Collection
*/
public function getAll()
{
$collection = new Collection();
$keys = $this->database->keys($this->namespace . ':*');
foreach ($keys as $key) {
list($namespace, $name) = explode(':', $key);
if (!$collection->has($name)) {
$collection->put($name, $this->get($name));
}
}
return $collection;
}
/**
* Get order by field name
*
* @return string
*/
public function getOrderBy()
{
$by = $this->getOrderByField();
if ($this->constraints->has($by)) {
$constraint = $this->constraints->get($by);
if ($constraint instanceof Closure) {
return $constraint;
} else {
return $by;
}
}
return '';
}
/**
* Add new settings meta info.
*
* @param Meta $meta
*/
public function addMeta(Meta $meta)
{
$group = $meta->getGroup();
if (!$this->groups->has($group)) {
$this->groups->put($group, new Collection());
}
if ($this->all->has($meta->getName())) {
throw new \RuntimeException('Settings with name `' . $meta->getName() . '` already exists .');
}
$this->all->put($meta->getName(), $meta);
//$this->groups->get($group);
$this->groups->get($group)->put($meta->getName(), $meta);
}
/**
* @param TransactionJournal $entry
*/
public function addOrCreateExpense(TransactionJournal $entry)
{
bcscale(2);
$accountId = $entry->account_id;
$amount = strval(round($entry->amount, 2));
if (bccomp('0', $amount) === -1) {
$amount = bcmul($amount, '-1');
}
if (!$this->expenses->has($accountId)) {
$newObject = new stdClass();
$newObject->amount = $amount;
$newObject->name = $entry->name;
$newObject->count = 1;
$newObject->id = $accountId;
$this->expenses->put($accountId, $newObject);
} else {
$existing = $this->expenses->get($accountId);
$existing->amount = bcadd($existing->amount, $amount);
$existing->count++;
$this->expenses->put($accountId, $existing);
}
}
/**
* @param TransactionJournal $entry
*/
public function addOrCreateIncome(TransactionJournal $entry)
{
// add each account individually:
$sources = TransactionJournal::sourceTransactionList($entry);
foreach ($sources as $transaction) {
$amount = strval($transaction->amount);
$account = $transaction->account;
$amount = bcmul($amount, '-1');
$object = new stdClass();
$object->amount = $amount;
$object->name = $account->name;
$object->count = 1;
$object->id = $account->id;
// overrule some properties:
if ($this->incomes->has($account->id)) {
$object = $this->incomes->get($account->id);
$object->amount = bcadd($object->amount, $amount);
$object->count++;
}
$this->incomes->put($account->id, $object);
}
}
/**
* agregar nuevo "otro" tratamiento al plan
* @param int $indice
* @param OtroTratamiento $tratamiento
*/
public function agregarOtroTratamiento($indice, OtroTratamiento $tratamiento)
{
if (is_null($this->listaOtrosTratamientos)) {
$this->listaOtrosTratamientos = new Collection();
}
/*if (count($this->listaTratamientos) === 2) {
throw new \Exception('Solo se permiten hasta dos tratamientos por diente');
}*/
// si ya está ocupada la posición, la elimina para permitir agregar uno nuevo
if ($this->listaOtrosTratamientos->has($indice)) {
$this->listaOtrosTratamientos->forget($indice);
}
$this->listaOtrosTratamientos->put($indice, $tratamiento);
}
/**
* Add another Menu instance and combined the two
* Groups with the same name get combined, but
* inherit each other's items
*
* @param Menu $menu
*
* @return Menu $menu
*/
public function add(Menu $menu)
{
foreach ($menu->getGroups() as $group) {
if ($this->groups->has($group->getName())) {
$existingGroup = $this->groups->get($group->getName());
$group->hideHeading(!$group->shouldShowHeading());
foreach ($group->getItems() as $item) {
$existingGroup->addItem($item);
}
} else {
$this->addGroup($group);
}
}
return $this;
}
/**
* @param TransactionJournal $entry
*/
public function addOrCreateExpense(TransactionJournal $entry)
{
// add each account individually:
$destinations = TransactionJournal::destinationTransactionList($entry);
foreach ($destinations as $transaction) {
$amount = strval($transaction->amount);
$account = $transaction->account;
if (bccomp('0', $amount) === -1) {
$amount = bcmul($amount, '-1');
}
$object = new stdClass();
$object->amount = $amount;
$object->name = $account->name;
$object->count = 1;
$object->id = $account->id;
// overrule some properties:
if ($this->expenses->has($account->id)) {
$object = $this->expenses->get($account->id);
$object->amount = bcadd($object->amount, $amount);
$object->count++;
}
$this->expenses->put($account->id, $object);
}
}
/**
* Instantiates and returns the asked resource.
* @param string The resource name
* @throws \Snorlax\Exception\ResourceNotImplemented If the resource is not available
* @return \Snorlax\Resource The instantiated resource
*/
public function getResource($resource)
{
if ($this->cache->has($resource)) {
return $this->cache->get($resource);
}
if (!$this->resources->has($resource)) {
throw new ResourceNotImplemented($resource);
}
$params = $this->resources->get($resource);
$instance = $params['instance'];
if (is_null($instance)) {
$class = $params['class'];
$instance = new $class($this->client);
}
return $this->cache[$resource] = $instance;
}
/**
* Get instance of connection type.
*
* @param string $name
* @param Closure|string|null $resolve
* @param boolean $fresh
* @return mixed
*/
public function connection($name, $resolve = null, $fresh = false)
{
$this->checkType($name);
if ($resolve && !$resolve instanceof Closure) {
$resolve = function ($root, array $args, ResolveInfo $info) use($resolve) {
return $this->resolveConnection($root, $args, $info, $resolve);
};
}
if (!$fresh && $this->connectionInstances->has($name)) {
$field = $this->connectionInstances->get($name);
$field['resolve'] = $resolve;
return $field;
}
$field = $this->connectionField($name, $resolve);
$this->connectionInstances->put($name, $field);
return $field;
}
/**
* @param Column $column
* @param Collection $foreignKeyColumns
* @param Collection $foreignTables
* @param Collection $indexes
* @return ColumnInterface
*/
protected function buildColumn(Column $column, Collection $foreignKeyColumns, Collection $foreignTables, Collection $indexes)
{
$uniqued = $indexes->filter(function (Index $index) use($column) {
return $index->getColumns()[0] == $column->getName() && $index->isUnique();
})->count() > 0;
if ($column->getAutoincrement()) {
return new ColumnAutoincrement($column, null, null, $uniqued);
} else {
if ($foreignKeyColumns->has($column->getName())) {
$table = $foreignKeyColumns->get($column->getName());
return new ColumnSelect($column, $table, $foreignTables->get($table), $uniqued);
} else {
if ($column->getType()->getName() == Type::INTEGER) {
return new ColumnNumericText($column, null, null, $uniqued);
} else {
return new ColumnText($column, null, null, $uniqued);
}
}
}
}
/**
* Process the payload.
* @param Collection $payload
* @return Collection
*/
public function process($payload)
{
$series = $payload->get('series');
$game = $series->game;
$creator = $payload->has('creator') ? $payload->get('creator')->model : $series->creator;
$videos = $payload->get('videos');
if ($payload->get('config')['mode'] === 'update') {
$videos = $videos->reject(function ($video) {
return $video->isPersisted();
});
}
$videos->each(function ($video) use($creator, $series, $game) {
$video->persist();
$video->relatesToGame($game);
$video->relatesToSeries($series);
$video->relatesToCreator($creator);
$video->model->touch();
});
return $payload;
}
/**
* Go
*
* Goes through all of the registered modules and attempts
* to activate them. Performs checks to ensure that modules
* that declare dependencies that have not been satisfied
* will not be activated.
*
* Registers any directories with the class loader
*
* @return void
*/
public function go()
{
$this->handlePreRegistered();
$toActivate = $this->registeredModules->all();
// This 'while' loop runs continuously allowing for modules
// to be checked multiple times which allows for dependencies.
while (count($toActivate) > 0) {
foreach ($toActivate as $name => $module) {
$canActivate = true;
$dependencies = $module->dependencies();
// If we've got dependencies, check them all to make sure all have been activated
// before activating this particular module.
if (!empty($dependencies)) {
foreach ($dependencies as $dependency) {
// First off, if this dependency hasn't even been register, we can never
// activate this module, so let's skip it and not try again.
if (!$this->registeredModules->has($dependency)) {
$canActivate = false;
$this->dispatcher->fire(self::EVENT_ACTIVATION_FAILED . ' ' . $name, $module);
unset($toActivate[$name]);
continue;
}
// At this point, the dependency has been registered but not activated,
// so let's skip this module and come back to it.
if (!$this->activeModules->has($dependency)) {
$canActivate = false;
}
}
}
// Now let's activate this sucka! Also, we remove it from the list
// so we don't try to activate it again.
if ($canActivate) {
$this->activeModules->put($name, $module->activate());
$this->dispatcher->fire(self::EVENT_ACTIVE . " {$name}", $module);
unset($toActivate[$name]);
}
}
}
$this->classLoader->register();
}
