I'm working on a text-based, rng-based motorsport "simulator" and I'm now at the point where I want to add qualifying. Since there's many different types of qualifying sessions across real life motorsport, I want to give the user the ability to use whatever format they like.
I have a Season model, to which the a qualifying format will belong. The different formats are defined as separate models themselves, for example ThreeSessionElimination and SingleSession. The migrations for these would look something like this;
Schema::create('three_session_eliminations', function (Blueprint $table) {
$table->unsignedBigInteger('id')->primary();
$table->foreignId('season_id')->constrained();
$table->unsignedInteger('q2_driver_count');
$table->unsignedInteger('q3_driver_count');
$table->unsignedInteger('runs_per_session');
$table->unsignedInteger('min_rng');
$table->unsignedInteger('max_rng');
$table->timestamps();
});
and
Schema::create('single_sessions', function (Blueprint $table) {
$table->unsignedBigInteger('id')->primary();
$table->foreignId('season_id')->constrained();
$table->unsignedInteger('runs_per_session');
$table->unsignedInteger('min_rng');
$table->unsignedInteger('max_rng');
$table->timestamps();
});
My initial thought was to add
public function season(): BelongsTo
{
return $this->belongsTo(Season::class);
}
to each qualifying format model, but obviously the inverse can't be a HasOne since there's different tables for each different format.
I've had a look at the "One To Many (Polymorphic)" relation documentation, but I can't quite wrap my head around how I should apply that in my case. Would I have to add a qualifying_format_id and qualifying_format_type to my Season model and remove the season_id column from each format migration to make this work?
Related
Is there a library where I am able to use a pivot table that points to the same model twice (i.e User) where I can have the PK as either column 2 or 3 for something like a friending or associating system?
Code Example
migration
Schema::create('friends', function (Blueprint $table) {
$table->id();
$table->unsignedBigInteger('requestor_id');
$table->unsignedBigInteger('requested_id');
$table->boolean('accepted')->default(0);
});
model
public function friends(){
return $this->[LibraryMethod](Friend::class, 'requestor_id', 'requested_id')->where('accepted', 1);
}
So then I could then either look at 'requestor_id' or 'requested_id' for my PK and get the PK of an associated User.
Ideally this should also work with eloquent functions.
I recognise that friends isn't the best example as you could have a handshake-like system, but for simple associations (i.e, between products) something like this would be pretty useful.
We have a need for multiple models to share a documents relation. Due to that, I've used a polymorphic one to many as per the below schema.
Schema::create('client', function (Blueprint $table) {
$table->id();
$table->string('name');
});
Schema::create('documents', function (Blueprint $table) {
$table->id();
$table->foreignId('type_id')->constrained('document_types');
$table->string('path'),
$table->morphTo('documentable');
});
Documents Model
public function documentable()
{
return $this->morphTo();
}
Client Model
public function documents()
{
return $this->morphMany(Document::class, 'documentable');
}
Each document will need to relate to a specific type. For example, one document might relate to the customers signed agreement and another may relate to a completely different document - These types will need to be 'query-able'.
What's the best way to proceed with this? As far as I'm aware, my options are;
Create a document_types table and set a belongsTo relation on the documents table.
Create an enum column on the documents table.
A side note on this. This will be consumed via an API. There will be the following resources:
Route::apiResource('client', 'ClientController');
Route::apiResource('client.documents', 'ClientDocumentController');
With whichever solution is proposed above, how would you propose the API handles the document type when creating/updating a document?
If the use of a documents_type table, would the end-user have to hit a resource for the document type, to obtain the document type ID prior to creating/updating a document?
If the use of enums, would the API just expect a string for the given document type?
Many thanks in advance.
I have an Image table as follow:
Schema::create('images', function (Blueprint $table) {
$table->bigIncrements('id');
$table->string('path');
$table->unsignedBigInteger('imageable_id')->nullable();
$table->string('imageable_type')->nullable();
$table->unsignedBigInteger('image_properties_id')->nullable();
$table->unsignedBigInteger('parent_id')->nullable();
$table->timestamp('created_at')->default(DB::raw('CURRENT_TIMESTAMP'));
});
I want to have polymorphic relation with images table and it works fine for most parts however the problem here is that some Models such as Post can have images for different purpose, for instance a post can have a image for post's cover and also images used in the post content.
Is it possible to access only images belonging to post's cover and not content?
I know that I can define custom type using morphmap, but is it possible to define two different types that points to the same Model and use these type to filter the results?
You can use the extended relationship to filter out as required.
Assuming you have images relationship on Post model, you can create two more as follows (one each for content and cover)
public function coverImages() {
return $this->images()->where('imageable_type', 'post/cover');
}
public function contentImages() {
return $this->images()->where('imageable_type', 'post/content');
}
With those relationships definition, now you can use each of them as an independent eloquent relationship.
I'm a newbie here and also in Laravel, so please excuse me. I have a table named 'products' and this table related to the 'recipes' table via many-to-one relation(One of the recipes has a lot of products). -'recipes' table keeps reference code- Here's where I stuck; the 'recipes' table has one-to-one relations to three different tables that keeping the "real" product recipes. Those tables have different recipe contents like,
Alkaline table;
Schema::create('alkalines', function (Blueprint $table) {
$table->bigIncrements('id');
$table->integer('recipe_id');
$table->integer('sodium_bicarbonate');
$table->timestamps();
});
Acets table;
Schema::create('acets', function (Blueprint $table) {
$table->bigIncrements('id');
$table->integer('recipe_id');
$table->integer('sodium_chloride');
$table->integer('acetic_acid');
$table->timestamps();
});
I'm able to fetch all relations if I start with one of these(e.g with Acet model). But if, I list all of products and try to fetch it's recipe, I have to use a bunch of 'if and else's. Just can't get the recipe like;
$product->recipe-> "one of the three recipe tables' content"
And my 'recipes' table:
Schema::create('recipes', function (Blueprint $table) {
$table->bigIncrements('id');
$table->string('ref');
$table->timestamps();
});
I believe it's easy, just missing something. Please help! Thanks in advance!
I think
You can get every relation individual them merge the arrays
like
$arr1=Alkalines::with('recipe')->get()->toArray();
$arr2==Acets::with('recipe')->get()->toArray();
$arr3=***************************;
array_merge($arr1,$arr2,$arr3)
Welcome to SO.
If you have relations set up properly, you can use 'collection->pluck()' to retrieve their results, no matter how deeply nested in different relations.
Example:
$game->players->stats won't work, because players is a collection that doesn't have a stats attribute, method or field.
So, what you can do is use pluck() and collapse() to retrieve result of relations:
$game->players->pluck('stats')->collapse()
I edit the code from #mohamedhassan a little bit, and it worked!
public function solutionMerge()
{
$arr1=Alkaline::with('recipe')->get();
$arr2=Acet::with('recipe')->get();
$arr3=Glucose::with('recipe')->get();
$solutionMerge = collect([$arr1,$arr2,$arr3]);
return $solutionMerge;
}
Just assigned arrays into a collection. And then use collapse().
And now, I'm able to fetch data like $solutionMerge->recipe->id
Thank you people, for your precious time and immense knowledge!
everything was working fine with a single Model, but now I am implementing more, I have noticed an issue.
I have several document Models which represent a different type of document. For now, let's say I have DocumentA and DocumentB.
Each Document allows file uploads, so I have created a FileUpload Model. A Document can have many FileUploads.
So, seems pretty straight forward at this point. My FileUpload table has a documentId field, which is a reference to the id field of the Document that is using it.
In DocumentA, I have something like so
public function uploadFile()
{
return $this->hasMany('App\UploadFile', 'documentId');
}
So DocumentA can have many UploadFiles, linked by the documentId.
DocumentB has the same function within its Model.
My problem lies with the UploadFiles model. Firstly, this model now has two belongTo events e.g.
public function documentA()
{
return $this->belongsTo('App\DocumentA', 'documentId');
}
public function documentB()
{
return $this->belongsTo('App\DocumentB', 'documentId');
}
This could be the problem, not sure if I can have multiple belongs to? My immediate problem however is to do with the migration of the doc_file table. At the moment I have this
Schema::table('doc_file', function (Blueprint $table) {
$table->integer('documentId')->unsigned()->default(0);
$table->foreign('documentId')->references('id')->on('document_a')->onDelete('cascade');
});
Schema::table('doc_file', function (Blueprint $table) {
$table->integer('documentId')->unsigned()->default(0);
$table->foreign('documentId')->references('id')->on('document_b')->onDelete('cascade');
});
So I am trying to provide foreign keys to my documents. When I try to migrate, it tells me that
Column already exists: 1060 Duplicate column name documentId
Am I handling my relationships correctly? Essentially, I have many documents, and each document can have many files.
Any assistance with my database relationships appreciated.
Many thanks
Looking at your problem at first glance, it seems that there is a little confusion for you regarding the concept model.
The Model Concept
A model is in fact a conceptualization of a real-world object as it is used to represent a real-world entity.
In other words, it represents a whole class of objects with similar properties. For instance a Car model would represent all cars, whether they are of type Lamborghini or Mercedez. The fact is that they all come under the Car classification.
Same concept goes in Eloquent, and with your use case; therefore a Document model is sufficient to represent both of your documents (DocumentA and DocumentB).
Eloquent Relationships
To refine what you've achieved so far, your models' relationships can be refactored as such:
Document Model
public function fileUploads(){
return $this->hasMany('App\FileUpload');
}
FileUpload Model
public function document(){
return $this->belongsTo('App\Document');
}
Based on the relationship "EACH document has MANY file uploads", and the inverse "EACH file upload BELONGS to exactly one document", as you can see, there is only one belongsTo() method in the FileUpload model to define the latter part of the relationship.
Similarly, the schema for the tables defining the above relationship are as follows:
// Schema for Document table
Schema::table('document', function (Blueprint $table) {
$table->increment('id');
$table->string('name', 100);
});
// Schema for FileUpload table
Schema::table('doc_file', function (Blueprint $table) { // file_uploads would have been a more friendly name in my opinion
$table->integer('documentId')->unsigned()->default(0); // note that `documentId` is interpreted as `documentid` in MySQL
$table->foreign('documentId')->references('id')->on('document')->onDelete('cascade');
});