CODEWITHSUNDEEP
jsonember.jsember-data
Jeep87c
Jeep87c

Reputation: 1120

Embedded json model with one-to-one relationship

I searched for a clear explanation on how this works but was not able to find one yet. I'm looking for a clear and detailed explanation with the assumption that I'm a total newbie with all these frameworks.

So here's my problem, I'm writing an app with frontend using Ember.js (with Ember-cli) and backend under Play-framework in Java. I'm trying to get my frontend to digest some json coming out from my API. Here's the json :

{
    "buildings": [
     {
         "id": 0,
         "createdDateTime": "2015-03-27T06:39:19.913Z",
         "address": {
             "id": 1,
             "city": "City",
             "civicNumber": 1287,
             "country": "Canada",
             "postalZipCode": "G1Q1Q9",
             "provinceOrState": "QC",
             "streetName": "A Street Name"
         },
         "cost": 1000000,
         "earnings": 2300,
         "mainPicturePath": "http://dummyimage.com/200x200/999/fff.png&text=Building",
         "type": "DUPLEX",
         "yearOfBuilt": 1998
    },
    {
        "id": 1,
        "createdDateTime": "2015-03-27T06:39:19.935Z",
        "address": {
            "id": 2,
            "city": "City",
            "civicNumber": 1289,
            "country": "Canada",
            "postalZipCode": "G1Q1Q9",
            "provinceOrState": "QC",
            "streetName": "A Street Name"
        },
        "cost": 980000,
        "earnings": 670,
        "mainPicturePath": "http://dummyimage.com/200x200/999/fff.png&text=Building",
        "type": "TRIPLEX",
        "yearOfBuilt": 1980
    }]
}

And here's my emberjs code :

//models/building.js
export default DS.Model.extend({
    type: DS.attr('string'),
    address: DS.belongsTo('address', {embedded: 'always'}),
    cost: DS.attr('number'),
    yearOfBuilt: DS.attr('number'),
    earnings: DS.attr('number'),
    createdDateTime: DS.attr('date'),
    mainPicturePath: DS.attr('string')
});

//models/address.js
export default DS.Model.extend({
    civicNumber: DS.attr('number'),
    streetName: DS.attr('string'),
    city: DS.attr('string'),
    provinceOrState: DS.attr('string'),
    country: DS.attr('string'),
    postalZipCode: DS.attr('string'),
    building: DS.belongsTo('building', {embedded: 'always'})
});

//serializers/building.js
export default DS.RESTSerializer.extend(DS.EmbeddedRecordsMixin, {
    attrs: {
        address: {embedded: 'always'}
    }
});

This doesn't throw any errors and works fine. The problem is, I don't fully understand the code for the embedded object address in building (I do understand how the DS models, the export from ember-cli and the belongsTo work). Could someone explains me in details how does it works (the RESTSerializer with EmbeddedRecordsMixin, the {embedded: 'always'} attribute and the other available options)? Any clarifications will be more than appreciated.

Lets also bring this to the next level, say I do not want to have an id for each address since they should never be used more than once (cannot have 2 buildings at the same address). How would I achieve that? Maybe I will store the address in the same record of my building object in the db and don't want an extra table for addresses. Based on these solutions, what would be the best approach (feel free to propose better solution if you have)?

Please be advised that I have already read the following links :

Thank you!

Upvotes: 2

Views: 527

Answers (1)

Kori John Roys
Kori John Roys

Reputation: 2661

The answers to most of your questions can be found by closely reading the EmbeddedRecordsMixin Docs

Specifically:

using { embedded: 'always' } as an option to DS.attr is not a valid way to setup embedded records.

(meaning as long as you've defined your belongsTo relationship you're good)

and

The attrs option for a resource { embedded: 'always' } is shorthand for:

1 {   
2   serialize: 'records',   
3   deserialize: 'records' 
4 }

But the real answer is, it's all in the code! Go read here and a little bit further down here, it's written pretty well and you should be able to trace what's going on.

Basically what happens is once you tell the serializer that there are embedded records (via {key: {embedded: 'always' } }), it will find that key in your JSON and deserialize it into an Ember object (as long as it finds a defined Ember object with that key, in your case 'address').

As far as your next level questions, I'd respond with my own question: Do your buildings have tenants? If so, they will probably have addresses, and you'll likely want to access it through tenant.address, rather than tenant.building.address, so go ahead and make address it's own table. It will likely save you some headaches in the near future.

Upvotes: 1

Related Questions