Sequelize associations hasOne, belongsTo

Le problème est que je ne peux pas obtenir de travail la relation hasOne, ce qui n'est pas désireux de charge à l'état d'objet de type.

Toutes les requêtes sont effectuées sur des tables existantes.

Voici la table des clients, ce qui est important, c'est la cst_state_type champ:

module.exports = function(sequelize, DataTypes) {

    return sequelize.define('customer', {

        customer: {
            type: DataTypes.INTEGER,
            primaryKey: true,
            autoIncrement: true,
            allowNull: true,
            validate: {
                isNumeric: true
            }
        },
        first_name: {
            type: DataTypes.STRING(100),
            validate: {
                isAlphanumeric: true
            }
        },
        last_name: DataTypes.STRING(100),
        identity_code: {
            type: DataTypes.STRING(20),
            allowNull: true,
            validate: {
                isNumeric: true
            }
        },
        note: DataTypes.STRING(1000),
        birth_date: DataTypes.DATE,


        created_by: DataTypes.INTEGER,
        updated_by: DataTypes.INTEGER,

        cst_type: DataTypes.INTEGER,
        cst_state_type:  {
            type: DataTypes.INTEGER,
        }

    }, {
        tableName: 'customer',

        updatedAt: 'updated',
        createdAt: 'created',
        timestamps: true
    });
};

cst_state_type table:

module.exports = function(sequelize, DataTypes) {

    return sequelize.define('StateType', {

        cst_state_type: {
            type: DataTypes.INTEGER,
            primaryKey: true,
            autoIncrement: true,
            validate: {
            }
        },
        name: DataTypes.STRING(100),
    }, {
        tableName: 'cst_state_type',
        timestamps: false
    });
};

Comment les relations sont décrites:

  global.db.Customer.hasOne(global.db.StateType, {
    foreignKey: 'cst_state_type',
    as: 'state_type'
  });

  global.db.StateType.belongsTo(global.db.Customer, {
    foreignKey: 'cst_state_type'
  });

Et la création d'désireux de chargement requête:

    db.Customer.findAll( {
        include: [
            { model: db.Address, as: 'addresses' },
            { model: db.StateType, as: 'state_type' }
        ]
    })
        .success(function (customers) {
            res.json(200, customers);
        })
        .fail(function (error) {
            res.json(500, { msg: error });
        });

OriginalL'auteur Risto Novik | 2013-09-29

3

Je suis assez sûr que l'erreur est dans votre association, quelque part. De la façon dont vous avez décrit votre structure de la table, les assocations devrait ressembler à quelque chose comme ceci:
```
global.db.Customer.belongsTo(global.db.StateType, {
    foreignKey: 'cst_state_type',
    as: 'state_type'
});

global.db.StateType.hasMany(global.db.Customer, {
    foreignKey: 'cst_state_type'
});
```
Ce que je comprends, le même état peut être attribué à beaucoup de clients, donc StateType.hasMany. La relation de client -> statetype est une "association", ce qui signifie que la clé étrangère est dans la table client. Pour cela vous avez besoin belongsTo

OriginalL'auteur Jan Aagaard Meier

Merci pour vous réponse, il m'a beaucoup aidé. Vous pouvez également ajouter les relations directement dans votre modèle en utilisant classmethods. J'ai ajouté un exemple ci-dessous, espérons que cette aide!

Utilisateur Modèle (fichier)

module.exports = function(sequelize, DataTypes){
    var User = sequelize.define(
        'User', {
            name: {
                type: DataTypes.STRING,
                allowNull: false
            }
        },
        {
            classMethods:{
                associate:function(models){
                    User.hasMany(models.Comment, { foreignKey: 'userId'} );
                }
            }
        }

    );
    return User;
};

Commentaire Modèle (fichier):

module.exports = function(sequelize, DataTypes){
    var Comment = sequelize.define(
        'Comment', {
            text: {
                type: DataTypes.STRING,
                allowNull: false
            }
        },
        {
            classMethods:{
                associate:function(models){
                    Comment.belongsTo(models.User, { foreignKey:'userId'} );
                }
            }
        }

    );
    return Comment;
};

Vous n'avez pas à définir le foreignkey, sequelize va la traiter si vous ne spécifiez pas les clés étrangères.

Puis dans la requête:

models.Comment.find({
        where: { id: id },
        include: [
            models.User
        ],
        limit: 1
    })

Excellent exemple! Simple et fonctionnelle.

OriginalL'auteur Gerard

Vous devez vous connecter pour publier un commentaire.