Page Comparison

class comp_type_info_data extends entity {

    public const TABLE = 'comp_type_info_data';

    /**
     * Param
     *
     * @return has_one
     */
    public function param(): has_one {
		// This method accepts another argument - key, which defaults to id and will be true in most cases.
        return $this->has_one(comp_type_info_data_param::class, 'dataid'); 
    }
}

class comp_type_info_data_param extends entity {
    public const TABLE = 'comp_type_info_data_param';
}

$entity = comp_type_info_data::repository()
			->order_by('id')
			->first();

// This will load the related entity - or null if it does not exist
$entity->param()->one(); 

$entity = comp_type_info_data::repository()
			->order_by('id')
			->first();

// This will load the related entity if it hasn't been and will cache the results on the model.
$entity->param; 

/**

/*

/**

* @property-read client_settings_model $client_settings

$client_settings_entity  = new client_settings();

$name = 'test';

class course extends entity {

    public const TABLE = 'course';

    /**
     * Course modules
     *
     * @return has_many
     */
    public function modules(): has_many {
		// This method accepts another argument - key, which defaults to id and will be true in most cases.
        return $this->has_many(course_module::class, 'course'); 
    }
}

class course_module extends entity {
    public const TABLE = 'course_modules';
}

$course = course::repository()
			->order_by('id')
			->first();

// This will load and return all the related course modules
$modules = $course->modules()->get(); 
// Or using the property access
$modules = $course->modules;
// SQL: SELECT * FROM {course_modules} "course_modules" where "course_modules".course = ?, [$course->id]

class course extends entity {

    public const TABLE = 'course';

    /**
     * Course
     *
     * @return has_many
     */
    public function active_modules(): has_many {
        return $this->has_many(course_module::class, 'course')
					->where('active', 1); // In addition to key filtering, where condition will be added as well.
    }
}

class competency extends entity {

    public const TABLE = 'comp';

    /**
     * Scale values for this competency
     *
     * @return has_many_through
     */
    public function values(): has_many_through {
		// the arguments follow the path from the current one,
 		// through an intermediate table to the target table.
		// current -> intermediate -> target
        return $this->has_many_through(
            competency_scale_assignment::class,  // the intermediate entity class name
            competency_scale_value::class,       // the target entity class name
            'frameworkid',						 // the foreign key in the current table to the intermediate table
            'frameworkid',						 // the key to link to in the intermediate table
            'scaleid', 							 // the foreign key in the intermediate table to the target table
			'scaleid'							 // the key in the target table
		);
    }
}

class competency_scale_value extends entity {
    public const TABLE = 'comp_scale_values';
}

class competency_scale_assignment extends entity {
    public const TABLE = 'comp_scale_assignments';
}

$competency = competency::repository()
			->order_by('id')
			->first();

$competency->values;
// SQL: SELECT * FROM {comp_scale_values} "scale_values" JOIN {comp_scale_assignments} "scale_assignments" ON "scale_values".scaleid = "scale_assignments".scaleid where "scale_assignments".frameworkid = ?, [$competency->frameworkid]

class competency extends entity {

    public const TABLE = 'comp';

    /**
     * Scale for this competency
     *
     * @return has_one_through
     */
    public function scale(): has_one_through {
		// the arguments follow the path from the current one,
 		// through an intermediate table to the target table.
		// current -> intermediate -> target
        return $this->has_one_through(
            competency_scale_assignment::class,  // the intermediate entity class name
            scale::class,       				 // the target entity class name
            'frameworkid',						 // the foreign key in the current table to the intermediate table
            'frameworkid',						 // the key to link to in the intermediate table
            'scaleid', 							 // the foreign key in the intermediate table to the target table
			'id'								 // the key in the target table
		);
    }
}

class competency_scale extends entity {
    public const TABLE = 'comp_scale';
}

class competency_scale_assignment extends entity {
    public const TABLE = 'comp_scale_assignments';
}

$competency = competency::repository()
			->order_by('id')
			->first();

$course->scale; 
// SQL: SELECT * FROM {comp_scale} "scale" JOIN {comp_scale_assignments} "scale_assignments" ON "scale".id = "scale_assignments".scaleid where "scale_assignments".frameworkid = ?, [$competency->frameworkid]

class course extends entity {

    public const TABLE = 'course';

    /**
     * Course modules
     *
     * @return has_many
     */
    public function modules(): has_many {
		// This method accepts another argument - key, which defaults to id and will be true in most cases.
        return $this->has_many(course_module::class, 'course'); 
    }
}

class course_module extends entity {
    public const TABLE = 'course_modules';

	/**
     * A course entity
     *
     *
     * @return belongs_to
     */
	public function a_course(): belongs_to {
        // This is the example where the name of the foreign key will match the most logical relation name, so we call it a_course instead of course.
		// Belongs to takes key as another argument which we omit here as in the majority of the circumstances it will
        return $this->belongs_to(course::class, 'course'); 
    }
}

// ...
$courses = course::repository()->get();

foreach ($courses as $course) {
    // You want to get each course module here
    foreach ($courses->modules as $cm) {
        // Do something...
    }
}

// Running the above code will result in having an n+1 problem as it would first execute a query to get all the courses and then in the loop it will run a query to fetch each course module.
// SELECT * FROM {course} course;
// SELECT * FROM {course_modules} course_modules WHERE course = ? [$course->id]
// ... repeat it as many times as many courses you have

// You specify the relation name you want to loadit is also possible to specify multiple relations to load if you supply an array of relation names
$courses = course::repository()
    ->with('modules')  // multiple: ->with(['relation_a', 'relation_b']) or just  ->with('relation_a')->with('relation_b') 
    ->get();

foreach ($courses as $course) {
    // You want to get each course module here
    foreach($courses->modules as $cm) {
        // Do something...
    }
}

// Running the above code will result in executing two queries only:
// When the collection will be loaded, before the result is returned to the user, an extra query will run.
// SELECT * FROM {course} course;
// SELECT * FROM {course_modules} course_modules WHERE course IN (?,?,?,...) [array_column($courses, 'id')]

// After the query to fetch all the related entities has ran, it will automatically inject the correct entities into the main collection
// So by the time you are iterating over courses your modules will be there already and will not trigger extra database queries.

// Array syntax
$courses = course::repository()
    ->with(['relation_a', 'relation_b'])   
    ->get();

// Fluent interface
$courses = course::repository()
    ->with('relation_a')
    ->with('relation_b')
    ->get();

class course extends entity {

    public const TABLE = 'course';

    /**
     * List of always eager-loaded relations.
     *
     * @var string[]
     */
    protected $with = [
        'modules'
    ];

    /**
     * Course modules
     *
     * @return has_many
     */
    public function modules(): has_many {
        return $this->has_many(course_module::class, 'course');
    }
}

// ...
$courses = course::repository()
    ->with('modules:instance,section,idnumber') // We want to get only these columns
    ->get();

foreach ($courses as $course) {
    // You want to get each course module here
    foreach($courses->modules as $cm) {
        var_dump($cm->to_array());   
    }
}

// It will output something like:
/*

[
   'id' => 1,
   'instance' => 22,
   'section' => '...',
   'idnumber' => '...',
   'course' => 2,
]
*/

// ...
$courses = course::repository()
    ->with(['modules' => function(entity_repository $repository) {
        $repository->where('visibleoncoursepage', true)
                   ->order_by('added', 'desc');
    }])
    ->get();
// ...

// This ^^ will only load related models which have "visibleoncoursepage" flag set to true and the collection will be sorted by added field in a descending order.

// It is also possible to specify both: columns to load as well as extra conditions:
// ...
    ->with(['modules:added,module' => function(entity_repository $repository) {
        $repository->where('visibleoncoursepage', true)
                   ->order_by('added', 'desc');
    }])
// ...

// ...
$course = course::repository()->first(); // Will retrieve a course with id 1 for example

$course->modules()->update([
   'visible' => false,
]);

// Running the above query will set visible flag to false for all modules with course id 1

// ...
$course = course::repository()->first(); // Will retrieve a course with id 1 for example

$course->modules()->delete();

// Running the above query will delete all modules with course id 1