public function map($hash, $title = true)
{
if (strlen($hash) < 1) {
$hash = '9999999999';
}
if (Hashes::$items == null) {
$this->getItems();
}
$object = Hashes::$items->filter(function ($item) use($hash) {
return $item->hash == $hash;
})->first();
if ($object instanceof Hash) {
if ($title) {
return $object->title;
}
return $object;
} else {
if ($this->allowedRetry) {
$this->updateHashes();
return $this->map($hash, $title);
} else {
$classified = Hash::where('hash', '9999999999')->first();
if ($title) {
return $classified->title;
}
return $classified;
// throw new HashNotLocatedException($hash);
}
}
}
/**
* Execute the job.
*
* @return Collection
*/
public function handle()
{
return $this->bookings->filter(function ($booking) {
$value = 0;
$payed = 0;
foreach ($booking->customer_booking as $customer) {
if ($customer->price) {
$value += $customer->price->price;
}
}
foreach ($booking->payment as $payment) {
$payed += $payment->value;
}
if ($value === $payed) {
return true;
}
return false;
})->sortByDesc('id');
}
/**
* Return true if all API Key are still enable
*
* @param Collection $keys
* @return bool
*/
protected function isEnabledKey(Collection $keys)
{
// count keys with enable value and compare it to total keys number
$enabledKeys = $keys->filter(function ($item) {
return $item->enabled == 1;
})->count();
if ($enabledKeys == $keys->count() && $keys->count() != 0) {
return true;
}
return false;
}
public function match(array $models, Collection $results, $relation)
{
$match = $this->matchPHP;
foreach ($models as $model) {
$value = $results->filter(function ($result) use($match, $model) {
return $match($model, $result);
});
if ($value->count()) {
$model->setRelation($relation, $value);
}
}
return $models;
}
/**
* Get all roles as collection.
*
* @return \Illuminate\Database\Eloquent\Collection
*/
public function getRoles()
{
if (!$this->roles) {
$this->roles = $this->grantedRoles()->get();
$deniedRoles = $this->deniedRoles()->get();
foreach ($deniedRoles as $role) {
$deniedRoles = $deniedRoles->merge($role->descendants());
}
foreach ($this->roles as $role) {
if (!$deniedRoles->contains($role)) {
$this->roles = $this->roles->merge($role->descendants());
}
}
$this->roles = $this->roles->filter(function ($role) use($deniedRoles) {
return !$deniedRoles->contains($role);
});
}
return $this->roles;
}
/**
* Match the eagerly loaded results to their parents.
*
* @param array $models
* @param \Illuminate\Database\Eloquent\Collection $results
* @param string $relation
* @return array
*/
public function match(array $models, Collection $results, $relation)
{
// We will need the parent node placeholder so that we use it to extract related results.
$parent = $this->query->getQuery()->modelAsNode($this->parent->getTable());
/**
* Looping into all the parents to match back onto their children using
* the primary key to map them onto the correct instances, every single
* result will be having both instances at each Collection item, held by their
* node placeholder.
*/
foreach ($models as $model) {
$matched = $results->filter(function ($result) use($parent, $model) {
if ($result[$parent] instanceof Model) {
// In the case of fetching nested relations, we will get an array
// with the first key being the model we need, and the other being
// the related model so we'll just take the first model out of the array.
if (is_array($model)) {
$model = reset($model);
}
return $model->getKey() == $result[$parent]->getKey();
}
});
// Now that we have the matched parents we know where to add the relations.
// Sometimes we have more than a match so we gotta catch them all!
foreach ($matched as $match) {
// In the case of fetching nested relations, we will get an array
// with the first key being the model we need, and the other being
// the related model so we'll just take the first model out of the array.
if (is_array($model)) {
$model = reset($model);
}
$model->setRelation($relation, $match[$relation]);
}
}
return $models;
}
/**
* Search through the record list for one matching the provided path.
* @param string $path
* @param \Illuminate\Database\Eloquent\Collection $existing_media
* @return \Plank\Mediable\Media|null
*/
protected function getRecordForFile($path, $existing_media)
{
$directory = File::cleanDirname($path);
$filename = pathinfo($path, PATHINFO_FILENAME);
$extension = pathinfo($path, PATHINFO_EXTENSION);
return $existing_media->filter(function (Media $media) use($directory, $filename, $extension) {
return $media->directory == $directory && $media->filename == $filename && $media->extension == $extension;
})->first();
}
/**
* Execute the job.
*
* @return Collection
*/
public function handle()
{
return $this->bookings->filter(function ($booking) {
return !$booking->payment->count() ? true : false;
})->sortByDesc('id');
}
/**
* Match the eagerly loaded results to their parents.
*
* @param array $models
* @param \Illuminate\Database\Eloquent\Collection $results
* @param string $relation
* @return array
*/
public function matchOneOrMany(array $models, Collection $results, $relation, $type)
{
// We will need the parent node placeholder so that we use it to extract related results.
$parent = $this->query->getQuery()->modelAsNode($this->parent->getTable());
/**
* Looping into all the parents to match back onto their children using
* the primary key to map them onto the correct instances, every single
* result will be having both instances at each Collection item, held by their
* node placeholder.
*/
foreach ($models as $model) {
$matched = $results->filter(function ($result) use($parent, $relation, $model) {
if ($result[$parent] instanceof Model) {
return $model->getKey() == $result[$parent]->getKey();
}
});
// Now that we have the matched parents we know where to add the relations.
// Sometimes we have more than a match so we gotta catch them all!
foreach ($matched as $match) {
if ($type == 'many') {
$collection = $model->getRelation($relation);
$collection->push($match[$relation]);
$model->setRelation($relation, $collection);
} else {
$model->setRelation($relation, $match[$relation]);
}
}
}
return $models;
}
/**
* Get items from collection whose properties match a given attribute and value
*
* @param Collection $collection
* @param string $attribute
* @param mixed $value
*
* @return Collection
*/
protected function getByAttributeFromCollection(Collection $collection, $attribute, $value = null)
{
return $collection->filter(function ($item) use($attribute, $value) {
if (isset($item->{$attribute}) && $value) {
return $item->{$attribute} == $value;
}
return false;
});
}
/**
* Filters a forum collection by the "canView" permission
*
* @param Collection $forums
*
* @return Collection
*/
private function filterUnviewableForums(Collection $forums)
{
return $forums->filter(function (Forum $forum) {
return $this->permissionChecker->hasPermission('forum', $forum->getContentId(), $forum::getViewablePermission(), $this->guard->user());
});
}
public function transformPost(\Post $post, Collection $favorites, Collection $subscriptions)
{
$response = ['id' => $post->id, 'text' => $post->text, 'created_at' => $post->created_at, 'updated_at' => $post->updated_at, 'user' => $this->transformUserToSmall($post->user), 'attachments' => $this->transformAttachments($post), 'comments_count' => $post->comments->count(), 'likes' => $post->likes->count(), 'commented' => $post->commented(), 'liked' => $post->liked() ? 1 : 0, 'is_fav' => $favorites->filter(function ($favorite) use($post) {
return $favorite->id == $post->id;
})->count() == 1 ? 1 : 0, 'category' => ['id' => $post->category->id, 'title' => $post->category->title, 'subscribed' => $subscriptions->filter(function ($subscription) use($post) {
return $subscription->id == $post->category->id;
})->count() == 1 ? 1 : 0]];
// if ($comments)
// $response['comments'] = $this->transformComments($post->comments);
return $response;
}
/**
* Check if node is sibling for roots in collection
*
* @param Tree $node Tree node
* @param Collection $roots Collection of roots
*
* @return bool
*/
private function siblingOfRoot(Tree $node, Collection $roots)
{
return (bool) $roots->filter(function ($item) use($node) {
return $node->isSibling($item);
})->first();
}
public function returnProjectModels(Collection $collection)
{
$user = \Authorization::user();
$wishlist = WishModel::where('user_id', '=', $user->id)->get();
if ($user->userable_type == BuyerModel::class) {
$collection->filter(function ($item) use($wishlist) {
$wishlist->contains('project_id', $item->id) ? $item->wishlisted = true : ($item->wishlisted = false);
return $item;
});
}
return $this->withCollection($collection, new ProjectTransformer());
}
/**
* Retrieve all the forming guilds.
*
* @param \Illuminate\Database\Eloquent\Collection $guilds
* @return array
*/
protected function getFormingGuilds(Collection $guilds)
{
return $guilds->filter(function ($guild) {
return $guild->isForming();
});
}