javascript - tipos - Clave foránea poblada con un objeto

llaves foraneas mysql workbench codigo

Question

Me gustaría establecer una relación entre dos modelos Usuario y Tarea usando backbone-relational.

La relación entre los dos modelos es la siguiente:

taskModel.creator_id = userModel.id   

// TaskModel
var TaskModel = Backbone.RelationalModel.extend({

    relations: [
        {
            type: Backbone.HasOne,
            key: ''creator'',
            keySource: ''creator_id'',
            relatedModel: Users
        }
    ],

    // some code
});

// Task collection
var TaskCollection = Backbone.Collection.extend({

    model: TaskModel,

    // some code

});

// User Model
var User = Backbone.RelationalModel.extend({
    // some code
});

En realidad, el problema está en los modelos collection.models, por favor vea las imágenes adjuntas :

Por favor revisa este jsfiddle: http://jsfiddle.net/2bsE9/5/

var user = new User(),
    task = new Task(),
    tasks = new Tasks();

task.fetch();
user.fetch();
tasks.fetch();

console.log(user.attributes, task.attributes, tasks.models);

PD:

En realidad, estoy usando requireJs para obtener el UserModel , por lo que no puedo incluir comillas en el valor de RelatedModel.

define([
    ''models/user'',
    ''backbone'',
    ''relationalModel''
], function (User) {
    "use strict";

    var Task = Backbone.RelationalModel.extend({
        relations: [
            {
                type: Backbone.HasOne,
                key: ''creator'',
                keySource: ''creator_id'',
                relatedModel: User
            }
        ],
    });
);

Answer 1

Editar 2:

http://jsfiddle.net/2bsE9/13/

Actualicé el jsfiddle para reflejar los cambios que sugerí a continuación. Siempre que llame a JSON en su tarea, lo que llega al servidor es un objeto json con la propiedad creator_id configurada en la id real del usuario. El keyDestination aquí es redundante ya que la documentación establece que se establece automáticamente si usa keySource .

Editar:

https://github.com/PaulUithol/Backbone-relational#keysource

https://github.com/PaulUithol/Backbone-relational#keydestination

https://github.com/PaulUithol/Backbone-relational#includeinjson

La combinación de los tres anteriores podría resolver su problema.

var Task = Backbone.RelationalModel.extend({
    relations: [
        {
            type: Backbone.HasOne,
            // The User object can be accessed under the property ''creator''
            key: ''creator'',
            // The User object will be fetched using the value supplied under the property ''creator_id''
            keySource: ''creator_id'',
            // The User object will be serialized to the property ''creator_id''
            keyDestination: ''creator_id'',
            // Only the ''_id'' property of the User object will be serialized
            includeInJSON: Backbone.Model.prototype.idAttribute,


            relatedModel: User
        }
    ],
});

La documentación también establece que la propiedad especificada por keySource o keyDestination no debe ser utilizada por su código. No se puede acceder a la propiedad como un atributo.

Por favor intente esto y comente si eso soluciona su problema.

Por cierto, aquí hay una buena publicación de blog que utiliza backbone-relational de punta a punta. http://antoviaque.org/docs/tutorials/backbone-relational-tutorial/

Answer 2

Editar

Jsfiddle actualizado

El problema es que Backbone-Relational elimina explícitamente keySource para ''evitar las abstracciones con fugas''. Tiene una llamada codificada para unset el atributo, en Backbone-Relational:

// Explicitly clear ''keySource'', to prevent a leaky abstraction if ''keySource'' differs from ''key''.
if ( this.key !== this.keySource ) {
    this.instance.unset( this.keySource, { silent: true } );
}

Deberá sobrescribir el método de desarmado en su modelo de Task :

var Task = Backbone.RelationalModel.extend({
    urlRoot: '' '',

    relations: [
        {
            type: Backbone.HasOne,
            key: ''creator'',
            relatedModel: User,
            keySource: ''creator_id''
        }
    ],

    unset: function(attr, options) {
        if (attr == ''creator_id'') {
          return false;
        }

        // Original unset from Backbone.Model:
        (options || (options = {})).unset = true;
        return this.set(attr, null, options);
     },

    sync: function (method, model, options) {
        options.success({
            id: 1,
            name: ''barTask'',
            creator_id: 1
        });
    }
});

Los problemas obvios con este enfoque son que tendrá que modificar su código si el Backbone cambia su método Backbone.Model.unset o Backbone-Relational cambia su comportamiento keySource .