/**
  * Boot the application events.
  *
  * @return void
  */
 public function boot()
 {
     $this->registerTranslations();
     $this->registerConfig();
     $this->registerViews();
     Relation::morphMap(['quran_recordings' => \Modules\Quran\Entities\QuranRecording::class]);
 }

 /**
  * Boot the application events.
  *
  * @return void
  */
 public function boot(Router $router)
 {
     $router->model('uuser', '\\Modules\\Users\\Entities\\User');
     $router->model('urole', '\\Bican\\Roles\\Models\\Role');
     $this->registerTranslations();
     $this->registerConfig();
     $this->registerViews();
     Relation::morphMap(['users' => \Modules\Users\Entities\User::class]);
 }

 /**
  * Add the "has" condition where clause to the query.
  *
  * @param  \Illuminate\Database\Eloquent\Builder  $hasQuery
  * @param  \Illuminate\Database\Eloquent\Relations\Relation  $relation
  * @param  string  $operator
  * @param  int  $count
  * @param  string  $boolean
  * @return \Illuminate\Database\Eloquent\Builder
  */
 protected function addHasWhere(EloquentBuilder $hasQuery, Relation $relation, $operator, $count, $boolean)
 {
     $query = $hasQuery->getQuery();
     // Get the number of related objects for each possible parent.
     $relationCount = array_count_values($query->lists($relation->getHasCompareKey()));
     // Remove unwanted related objects based on the operator and count.
     $relationCount = array_filter($relationCount, function ($counted) use($count, $operator) {
         // If we are comparing to 0, we always need all results.
         if ($count == 0) {
             return true;
         }
         switch ($operator) {
             case '>=':
             case '<':
                 return $counted >= $count;
             case '>':
             case '<=':
                 return $counted > $count;
             case '=':
             case '!=':
                 return $counted == $count;
         }
     });
     // If the operator is <, <= or !=, we will use whereNotIn.
     $not = in_array($operator, array('<', '<=', '!='));
     // If we are comparing to 0, we need an additional $not flip.
     if ($count == 0) {
         $not = !$not;
     }
     // All related ids.
     $relatedIds = array_keys($relationCount);
     // Add whereIn to the query.
     return $this->whereIn($this->model->getKeyName(), $relatedIds, $boolean, $not);
 }

 protected function verifyRelation(ReflectionMethod $method, Relation $relationship)
 {
     $expectedRelatedModel = $this->relatedModel === get_class($relationship->getRelated());
     $expectedRelationName = get_class($relationship) === $this->type;
     $expectedReturnAnnotation = $this->getReturnAnnotation($method) === $this->type;
     return $expectedRelationName && $expectedRelatedModel && $expectedReturnAnnotation;
 }

 /**
  * @param Relation $relation
  * @param array    $excluded_ids
  */
 public static function deleteAllRelatedExcept(Relation $relation, $excluded_ids = [])
 {
     $related = $relation->getRelated();
     $key_name = $related->getKeyName();
     $query = $relation->getQuery();
     if (count($excluded_ids) > 0) {
         $query->whereNotIn($key_name, $excluded_ids);
     }
     $query->delete();
 }

 /**
  * @param $joinTableAlias
  * @param $currentTableAlias
  * @param BelongsTo|Relation $relation
  * @param string $columnsPrefix
  */
 protected function addJoinToQuery($joinTableAlias, $currentTableAlias, Relation $relation, $columnsPrefix = '')
 {
     $joinTableName = $relation->getRelated()->getTable();
     $joinTable = implode(' as ', [$joinTableName, $joinTableAlias]);
     $joinLeftCondition = implode('.', [$joinTableAlias, $relation->getOtherKey()]);
     $joinRightCondition = implode('.', [$currentTableAlias, $relation->getForeignKey()]);
     $this->query->leftJoin($joinTable, $joinLeftCondition, '=', $joinRightCondition);
     $columns = $this->getColumns($joinTableName);
     $prefix = static::$prefix . $columnsPrefix . $joinTableAlias . '---';
     foreach ($columns as $column) {
         $this->selectFromQuery($joinTableAlias, $column, $prefix . $column);
     }
 }

 public function __construct(array $config, ModelManager $modelManager, Model $model, EloquentRelation $eloquentRelation, FieldFactory $fieldFactory)
 {
     $this->checkNameConfig($config);
     $this->name = $config['name'];
     $this->slug = $config['name'];
     $this->relatedModel = $model;
     $this->eloquentRelation = $eloquentRelation;
     $this->fieldFactory = $fieldFactory;
     $this->modelManager = $modelManager;
     $this->config = $config;
     $this->setup();
     $this->modelAbstractor = \App::make('Anavel\\Crud\\Contracts\\Abstractor\\ModelFactory')->getByClassName(get_class($this->eloquentRelation->getRelated()), $this->config);
 }

 /**
  * DescendantsRelation constructor.
  *
  * @param QueryBuilder $builder
  * @param Model $model
  */
 public function __construct(QueryBuilder $builder, Model $model)
 {
     if (!NestedSet::isNode($model)) {
         throw new InvalidArgumentException('Model must be node.');
     }
     parent::__construct($builder, $model);
 }

 /**
  * Boot the application events.
  *
  * @return void
  */
 public function boot()
 {
     $this->registerTranslations();
     $this->registerConfig();
     $this->registerViews();
     Relation::morphMap(['paper_doc' => \Modules\Papers\Entities\PaperDoc::class, 'paper_semster_doc' => \Modules\Papers\Entities\PaperSemesterDoc::class]);
 }

 /**
  * Boot the application events.
  *
  * @return void
  */
 public function boot()
 {
     $this->registerTranslations();
     $this->registerConfig();
     $this->registerViews();
     Relation::morphMap(['order_quran_excuses' => \Modules\Orders\Entities\OrderQuranExcuse::class]);
 }

 /**
  * Add the constraints for a relationship count query.
  *
  * @param  \Illuminate\Database\Eloquent\Builder  $query
  * @param  \Illuminate\Database\Eloquent\Builder  $parent
  * @return \Illuminate\Database\Eloquent\Builder
  */
 public function getRelationCountQuery(Builder $query, Builder $parent)
 {
     if ($parent->getQuery()->from == $query->getQuery()->from) {
         return $this->getRelationCountQueryForSelfRelation($query, $parent);
     }
     return parent::getRelationCountQuery($query, $parent);
 }

 /**
  * Boot the application events.
  *
  * @return void
  */
 public function boot()
 {
     $this->registerTranslations();
     $this->registerConfig();
     $this->registerViews();
     Relation::morphMap(['teachers' => \Modules\Teachers\Entities\Teacher::class]);
 }

 /**
  * Add the constraints for a relationship query.
  *
  * @param  \Illuminate\Database\Eloquent\Builder  $query
  * @param  \Illuminate\Database\Eloquent\Builder  $parent
  * @param  array|mixed  $columns
  * @return \Illuminate\Database\Eloquent\Builder
  */
 public function getRelationQuery(Builder $query, Builder $parent, $columns = ['*'])
 {
     if ($parent->getQuery()->from == $query->getQuery()->from) {
         return $this->getRelationQueryForSelfRelation($query, $parent, $columns);
     }
     return parent::getRelationQuery($query, $parent, $columns);
 }

 /**
  * Boot the application events.
  *
  * @return void
  */
 public function boot()
 {
     $this->registerTranslations();
     $this->registerConfig();
     $this->registerViews();
     Relation::morphMap([]);
 }

 /**
  * Sort by issues tag group
  * Note: this sort will return the collection
  *
  * @param Eloquent\Relations\Relation $query
  * @param string                      $tagGroup
  * @param string                      $order
  *
  * @return Eloquent\Collection
  */
 public function sortByTag(Eloquent\Relations\Relation $query, $tagGroup, $order = 'asc')
 {
     // If tag group is string prefixed with tag:
     if (!is_numeric($tagGroup)) {
         $tagGroup = substr($tagGroup, strlen('tag:'));
     }
     $results = $query->get()->sort(function (Project\Issue $issue1, Project\Issue $issue2) use($tagGroup, $order) {
         $tag1 = $issue1->tags->where('parent.id', $tagGroup, false)->first();
         $tag2 = $issue2->tags->where('parent.id', $tagGroup, false)->first();
         $tag1 = $tag1 ? $tag1->name : '';
         $tag2 = $tag2 ? $tag2->name : '';
         if ($order === 'asc') {
             return strcmp($tag1, $tag2);
         }
         return strcmp($tag2, $tag1);
     });
     return $results;
 }

 /**
  * Boot the application events.
  *
  * @return void
  */
 public function boot()
 {
     $this->registerTranslations();
     $this->registerConfig();
     $this->registerViews();
     StudentGrade::creating(function ($grade) {
         $grade->semester_id = semester()->id;
     });
     Relation::morphMap(['students' => \Modules\Students\Entities\Student::class]);
 }

 /**
  * Register the User module service provider.
  *
  * @return void
  */
 public function register()
 {
     // This service provider is a convenient place to register your modules
     // services in the IoC container. If you wish, you may make additional
     // methods or service providers to keep the code more focused and granular.
     App::register('App\\Modules\\User\\Providers\\RouteServiceProvider');
     App::register('App\\Modules\\User\\Providers\\RepositoryServiceProvider');
     Relation::morphMap([config('user_module.user_types.administrator') => App\Modules\User\Models\Administrator::class]);
     $this->registerNamespaces();
 }

 /**
  * Register any package services.
  *
  * @return void
  */
 public function register()
 {
     $configPath = realpath(__DIR__ . '/../config/loggableModels.php');
     $this->publishes([$configPath => $this->getConfigPath()], 'config');
     $this->publishes([realpath(__DIR__ . '/../database/migrations/') => database_path('migrations')], 'migrations');
     // Define Custom Polymorphic Types
     Relation::morphMap([]);
     $this->mergeConfigFrom($configPath, 'loggableModels');
     $this->app->bind('loggable-models', function () {
         return new ModelLogHandler();
     });
 }

 /**
  *	Adds a join clause to the current relatedQuery using the relation Object.
  *
  *	@param \Illuminate\Database\Query 											$query
  *	@param \Illuminate\Database\Eloquent\Relations\Relation $relation
  *	@return \Illuminate\Database\Querys
  */
 protected function joinRelated($query, $relation)
 {
     $parentTable = $relation->getParent()->getTable();
     $parentKey = $relation->getParent()->getKeyName();
     $relatedTable = $relation->getRelated()->getTable();
     $fk = $relation->getForeignKey();
     $relationType = str_replace('Illuminate\\Database\\Eloquent\\Relations\\', '', get_class($relation));
     switch ($relationType) {
         case 'BelongsTo':
             $query->join($relatedTable, "{$relatedTable}.{$parentKey}", '=', "{$parentTable}.{$fk}");
             break;
         case 'HasOne':
         case 'HasMany':
         case 'MorphOne':
         case 'MorphMany':
             $query->join($relatedTable, "{$parentTable}.{$parentKey}", '=', "{$fk}");
             break;
         case 'BelongsToMany':
             $table = $relation->getTable();
             $otherKey = $relation->getOtherKey();
             $query->join($table, "{$parentTable}.{$parentKey}", '=', "{$fk}")->join($relatedTable, "{$relatedTable}.{$parentKey}", '=', "{$otherKey}");
             break;
         default:
             break;
     }
     return $query;
 }

 /**
  * Sets up the existing relationship wheres.
  *
  * @param \Illuminate\Database\Eloquent\Relations\Relation $relationship
  * @param string                                           $tableAlias
  * @param string                                           $pivotAlias
  * @param string                                           $pivot
  *
  * @return string
  */
 public function getRelationshipWheres($relationship, $tableAlias, $pivotAlias = null, $pivot = null)
 {
     //get the relationship model
     $relationshipModel = $relationship->getRelated();
     //get the query instance
     $query = $relationship->getQuery()->getQuery();
     //get the connection instance
     $connection = $query->getConnection();
     //one element of the relationship query's wheres is always useless (it will say pivot_table.other_id is null)
     //depending on whether or not softdeletes are enabled on the other model, this will be in either position 0
     //or 1 of the wheres array
     array_splice($query->wheres, method_exists($relationshipModel, 'getDeletedAtColumn') ? 1 : 0, 1);
     //iterate over the wheres to properly alias the columns
     foreach ($query->wheres as &$where) {
         //alias the where columns
         $where['column'] = $this->aliasRelationshipWhere($where['column'], $tableAlias, $pivotAlias, $pivot);
     }
     $sql = $query->toSql();
     $fullQuery = $this->interpolateQuery($sql, $connection->prepareBindings($query->getBindings()));
     $split = explode(' where ', $fullQuery);
     return isset($split[1]) ? $split[1] : '';
 }