public function send(Collection $data)
{
$validator = $this->validator($data->toArray(), $this->type);
if (!$validator->fails()) {
Mailer::send("emails.{$this->type}", $data->toArray(), function ($message) use($data) {
$fromAddress = $data->get('from_address');
$fromName = $data->get('from_name');
$toAddress = $data->get('to_address');
$toName = $data->get('to_name');
$cc = $data->get('cc[]', []);
$bcc = $data->get('bcc[]', []);
// Send the message
$message->from($fromAddress, $fromName);
$message->to($toAddress, $toName)->subject($data->get('subject'));
foreach ($cc as $address) {
$message->cc($address, null);
}
foreach ($bcc as $address) {
$message->bcc($address, null);
}
});
} else {
// Validation failed
return ['success' => 0, 'status' => "Failed to validate message", 'messages' => $validator->getMessageBag()->all(), 'data' => $data, 'type' => $this->type];
}
if (!count(Mailer::failures())) {
$this->sent_at = Carbon::now();
Log::info("Sent {$this->type} email");
return ['success' => 1, 'status' => "successfully sent message", 'data' => $data, 'type' => $this->type];
}
Log::info("Failed to send {$this->type} email");
return ['success' => 0, 'status' => "failed to send message", 'messages' => "failed to send message", 'data' => $data, 'type' => $this->type];
}
/**
* @param GrantableInterface $grantable
* @param $action
*
* @return mixed
*/
public function isAllow(GrantableInterface $grantable, $action)
{
if (is_null($this->permissions) || $this->permissions->isEmpty()) {
$this->initialize($grantable);
}
return $this->permissions->get($action, false);
}
/**
* @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);
}
/**
* obtener una evaluacion en especÃfico
* @param int $id
* @return mixed|null
*/
public function evaluacion($id)
{
if ($this->buscarEvaluacion($id) === false) {
return null;
}
return $this->listaEvaluaciones->get($id);
}
public function applications()
{
$apps = $this->items->get('applications');
if (is_array($apps)) {
$apps = $this->transformToCollections($apps);
}
return new Collection($apps);
}
/**
* @param File $image
* @param string $prefix
* @param String $path
* @return string
*/
public function moveFile(File $image, $path, $prefix = '')
{
$extension = $image->guessExtension();
$code = strtoupper($this->request->get('code'));
$fileName = $code . '-' . $prefix . '.' . $extension;
$image->move(public_path() . $path, $fileName);
return $path . $fileName;
}
/**
* 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;
}
/**
* @param string|Model $model
* @param string $query
* @param int|null $perPage
* @param string $pageName
*
* @return LengthAwarePaginator|Collection
* @throws \Exception
*/
public function searchIn($model, $query = "", $perPage = null, $pageName = 'page')
{
if ($model instanceof Model) {
$model = get_class($model);
}
if (!$this->models->offsetExists($model)) {
throw new \Exception("Search engine for model [{$model}] not found");
}
return $this->_search([$this->models->get($model)], $query = "", $perPage = null, $pageName = 'page');
}
/**
* @param $provider
*
* @return Providers\ProvidersInterface;
* @throws \Exception
*/
private function loadProvider($provider)
{
if (!isset($this->providersAvailable[$provider])) {
throw new \Exception('Lavatar provider ' . $provider . ' does not exist.');
}
$this->providersLoadeds[$provider] = app($this->providersAvailable[$provider]);
$options = $this->config->get($provider, array());
$this->providersLoadeds[$provider]->setupOptions($options);
return $this->providersLoadeds[$provider];
}
public function it_should_generate_a_module(Filesystem $filesystem, Mustache_Engine $mustache, Collection $c)
{
$filesystem->get('template.stub')->shouldBeCalled()->willReturn('template');
$filesystem->put('js/modules/tacos/index.js', 'output')->shouldBeCalled();
$mustache->render('template', ['model_path' => 'modules/tacos/models/taco', 'model' => 'Taco', 'collection_path' => 'modules/tacos/collections/tacos', 'collection' => 'TacoCollection', 'view_path' => 'modules/tacos/views/taco_view', 'view' => 'TacoView'])->shouldBeCalled()->willReturn('output');
$c->get('model')->willReturn(new BackboneComponent('', 'modules/tacos/models/taco', 'Taco'))->shouldBeCalled();
$c->get('view')->willReturn(new BackboneComponent('', 'modules/tacos/views/taco_view', 'TacoView'))->shouldBeCalled();
$c->get('collection')->willReturn(new BackboneComponent('', 'modules/tacos/collections/tacos', 'TacoCollection'))->shouldBeCalled();
$f = new BackboneComponent('js/modules/tacos/index.js', 'index', 'Index');
$this->generate($f, 'template.stub', $c);
}
/**
* Process the payload.
* @param Collection $payload
* @return Collection
*/
public function process($payload)
{
$series = $payload->get('series');
$game = $series->game;
$creator = $payload->get('creator');
$creator->persist();
$creator->relatesToGame($game);
$series->creator()->associate($creator->model);
$creator->model->touch();
return $payload;
}
/**
* 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;
}
/**
* 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 \Spatie\SlashCommand\Handlers\BaseHandler
*
* @throws \Spatie\SlashCommand\Exceptions\RequestCouldNotBeHandled
*/
protected function determineHandler()
{
$handler = collect($this->config->get('handlers'))->map(function (string $handlerClassName) {
if (!class_exists($handlerClassName)) {
throw InvalidHandler::handlerDoesNotExist($handlerClassName);
}
return new $handlerClassName($this->request);
})->filter(function (HandlesSlashCommand $handler) {
return $handler->canHandle($this->request);
})->first();
if (!$handler) {
throw RequestCouldNotBeHandled::noHandlerFound($this->request);
}
return $handler;
}
/**
* 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;
}
/**
* Find in which collection the given dependency exists
* @param string $dependency
* @return array
*/
private function findDependenciesForKey($dependency)
{
if ($this->css->get($dependency)) {
return [$this->css->toArray(), 'css'];
}
return [$this->js->toArray(), 'js'];
}
/**
* Returns the group MenuPresence instance in the menuGroup tree by dot notation key.
* Recursive.
*
* @param string $dotKey
* @param null|MenuPresenceInterface $parent
* @return false|MenuPresenceInterface
*/
protected function getDotMenuGroupPresence($dotKey, $parent = null)
{
$keys = explode('.', $dotKey);
$firstKey = array_shift($keys);
// For the top level, find the outer group and start recursion, or
// return the outer group if it is not a nested key.
if (!$parent) {
$parent = $this->menuGroups->get($firstKey);
if (!$parent) {
return false;
}
if (!count($keys)) {
return $parent;
}
return $this->getDotMenuGroupPresence(implode('.', $keys), $parent);
}
// For nested groups, find the relevant child and keep going deeper
// until we get it.
if (!$parent->children()) {
return false;
}
if (!count($keys)) {
return $parent->children()[$firstKey];
}
return $this->getDotMenuGroupPresence(implode('.', $keys), $parent->children()[$firstKey]);
}
/**
* Get the value of a field
*
* @param string $field The field's name
*
* @return mixed
*/
public function get($field, $fallback = null)
{
// Plain array
if (is_array($this->items) and !str_contains($field, '[')) {
return parent::get($field, $fallback);
}
// Transform the name into an array
$value = $this->items;
$field = $this->parseFieldAsArray($field);
// Dive into the model
foreach ($field as $relationship) {
// Get attribute from model
if (!is_array($value)) {
$value = $this->getAttributeFromModel($value, $relationship, $fallback);
if ($value === $fallback) {
break;
}
continue;
}
// Get attribute from model
if (array_key_exists($relationship, $value)) {
$value = $value[$relationship];
} else {
foreach ($value as $key => $submodel) {
$value[$key] = $this->getAttributeFromModel($submodel, $relationship, $fallback);
}
}
}
return $value;
}
/**
* Get an addon.
*
* @param mixed $key
* @param null $default
* @return Addon|mixed|null
*/
public function get($key, $default = null)
{
if (!($addon = parent::get($key, $default))) {
return $this->findBySlug($key);
}
return $addon;
}
/**
* @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;
});
}
}
/**
* Process the payload.
* @param Collection $payload
* @return Collection
*/
public function process($payload)
{
$series = $payload->get('series');
$series->touch();
$series->save();
return $payload;
}
/**
* Returns a module by key.
*
* @param string $key
* @return ModuleInterface|false
*/
public function get($key)
{
if (!$this->has($key)) {
return false;
}
return $this->modules->get($key);
}
/**
* @test
* @group failing
*/
public function itCanPaginateConnectionWithConnectionType()
{
$id = $this->encodeGlobalId(UserStubConnectionType::class, $this->user->id);
$first = 2;
$query = $this->getQuery($id, $first);
$graphql = app('graphql');
$graphql->schema()->type('user', UserStubConnectionType::class);
$graphql->schema()->type('task', TaskStubType::class);
$data = $this->executeQuery($query);
$edges = array_get($data, 'data.node.tasks.edges');
$this->assertCount(2, $edges);
$this->assertEquals($this->tasks->get(0)->title, array_get($edges, '0.node.title'));
$this->assertEquals($this->tasks->get(1)->title, array_get($edges, '1.node.title'));
$this->assertNotNull(array_get($edges, '1.cursor'));
$after = array_get($edges, '1.cursor');
$query = $this->getQuery($id, $first, $after);
$data = $this->executeQuery($query);
$edges = array_get($data, 'data.node.tasks.edges');
$this->assertCount(2, $edges);
$this->assertEquals($this->tasks->get(2)->title, array_get($edges, '0.node.title'));
$this->assertEquals($this->tasks->get(3)->title, array_get($edges, '1.node.title'));
$after = array_get($edges, '1.cursor');
$query = $this->getQuery($id, $first, $after);
$data = $this->executeQuery($query);
$edges = array_get($data, 'data.node.tasks.edges');
$this->assertCount(2, $edges);
$this->assertEquals($this->tasks->get(4)->title, array_get($edges, '0.node.title'));
$this->assertEquals($this->tasks->get(5)->title, array_get($edges, '1.node.title'));
}
protected function setApproved($name, array $fields = [])
{
$columns = [];
foreach ($fields as $key => $value) {
$columns[] = is_string($key) && !is_numeric($key) ? $key : $value;
}
$settings = $this->allowed->get($name);
$custom = false;
if (is_array($settings) && isset($settings['custom'])) {
$custom = $settings['custom'];
}
if (count($columns) > 0) {
if ($custom instanceof \Closure) {
$config = $this->config;
$this->approved[$name] = function ($query) use($columns, $custom, $config) {
$query->select($columns);
$custom($config, $query);
};
} else {
$this->approved[$name] = function ($query) use($columns) {
$query->select($columns);
};
}
} else {
$this->approved[] = $name;
}
}
/**
* @param $tenant
*
* @throws TenantColumnUnknownException
*
* @return mixed
*/
public function getTenantId($tenant)
{
if (!$this->hasTenant($tenant)) {
throw new TenantColumnUnknownException('$tenant must be a string key or an instance of \\Illuminate\\Database\\Eloquent\\Model');
}
return $this->tenants->get($this->getTenantKey($tenant));
}
/**
* project
*
* @param $name
* @return \Codex\Codex\Project
*/
public function getProject($name)
{
if (!$this->hasProject($name)) {
throw new \InvalidArgumentException("Project [{$name}] could not be found in [{$this->rootDir}]");
}
return $this->projects->get($name);
}
/**
* 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;
}
/**
* @param $key
* @param $resource
* @return mixed
*/
private function getResource($key, $resource)
{
if ($this->notFetched($key)) {
$result = $this->client->retrieve($resource, $key);
$this->fetched->put($key, $result);
}
return $this->fetched->get($key);
}
/**
* @param $key
* @param $amount
* @param $item
*/
protected function addExistsIntoItems($key, $amount, $item)
{
$temp = $this->_items->get($key);
$temp['amount'] += $amount;
$this->_items->forget($key);
$this->_items->push($temp);
$this->_totalPrice += $amount * $item->getPrice();
}
/**
* @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);
}
}
