Sequelize: Fehler beim Verschachteln der Assoziation

Question

Hallo ich bin neu mit Sequelize und ich bin wirklich verloren, wie man Beziehungen verwaltet. Ich möchte 1: N-Beziehung festlegen, aber wenn ich die Ergebnisse sehe, erhalte ich die Beziehungsdaten nicht. Ich arbeite mit 2 Tabellen in diesem Moment, medicos und hospitals wo hospitals kann viele doctors haben aber doctors hat nur eine hospital.

Das ist meine doctors Tabelle: models/doctors.js

module.exports = function(sequelize, DataTypes) { 
     return sequelize.define('doctors', { 
     id: { 
      type: DataTypes.INTEGER(11), 
      allowNull: false, 
      primaryKey: true, 
      autoIncrement: true 
     }, 
     name: { 
      type: DataTypes.STRING, 
      allowNull: false 
     }, 
     lastName: { 
      type: DataTypes.STRING, 
      allowNull: false 
     }, 
     SSN: { 
      type: DataTypes.STRING, 
      allowNull: false 
     }, 
     speciality: { 
      type: DataTypes.ENUM('Doctor','Geriatrician'), 
      allowNull: false 
     }, 
     idHospital: { 
      type: DataTypes.INTEGER(11), 
      allowNull: false, 
     }, 
     }, { 
     tableName: 'doctors', 
     freezeTableName: true, 
     classMethods: { 
      associate: models => { 
      models.doctors.belongsTo(models.hospitals, { 
       foreignKey: "idHospital" 
      }) 
     } 
     } 
    }); 
     }); 
    }; 

und dies ist hospitals ein: models/hospitals.js

module.exports = function(sequelize, DataTypes) { 
    return sequelize.define('hospitals', { 
    id: { 
     type: DataTypes.INTEGER(11), 
     allowNull: false, 
     primaryKey: true, 
     autoIncrement: true 
    }, 
    name: { 
     type: DataTypes.STRING, 
     allowNull: false 
    }, 
    idData: { 
     type: DataTypes.INTEGER(11), 
     allowNull: false, 
     references: { 
     model: 'data', 
     key: 'id' 
     } 
    }, 
    }, { 
    tableName: 'hospitals', 
    freezeTableName: true, 
    classMethods: { 
     associate: models => { 
     models.hospitals.hasMany(models.doctors, { 
     foreignKey: "idHospital" 
     }) 
    } 
    } 
    }); 
}; 

In Verwaltung meiner Modelle mit dieser Datei models/index.js

'use strict'

module.exports = (connection) => { 
    const Users      = connection.import('users'), 
     States     = connection.import('states'), 
     Cities     = connection.import('cities'), 
     Data      = connection.import('data'), 
     Patient     = connection.import('patients'), 
     Hospitals     = connection.import('hospitals'), 
     Doctors     = connection.import('doctors'), 


     Doctors.belongsTo(Hospitals) 
     Hospitals.hasMany(Doctors) 
     require('../controllers/patients')(Users) 
     require('../controllers/personal')(Doctors, Hospitals) 
} 

dieses ist mein controller/controllers/personal.js

'use strict' 

module.exports = (Doctors) => { 

    const express = require('express'), 
     router = express.Router() 
    router 
    .get('/', (req, res) => { 
    Doctors.findAll({ include: [{ model: Hospitals, include: [Doctors], }], }).then((Doctors) => console.log(Doctors)); 
    }) 

und mein Haupt index

'use strict' 

const express  = require('express'), 
     path   = require('path'), 
     bodyParser = require('body-parser'), 
     Sequelize  = require('sequelize'), 
     port   = process.env.PORT || 3000, 
     app   = express(), 
     connection = new Sequelize('Matadero', 'root', 'root'); 

app.use(bodyParser.json()) 
app.use(bodyParser.urlencoded({extended:true})) 

app.set('view engine', 'ejs') 
app.set('views', path.resolve(__dirname, 'client', 'views')) 

app.use(express.static(path.resolve(__dirname, 'client'))) 

app.get('/', (req, res) => { 
    res.render('admin/index.ejs') 
}) 

const onListening =() => console.log(`Successful connection at port: ${port}`) 



require('./models')(connection) 

app.listen(port, onListening) 

const patients = require('./controllers/patients'), 
     personal = require('./controllers/personal') 


app.use('/api/patients', patients) 
app.use('/api/personal', personal) 

Der Fehler ich erhalte: Unhandled rejection Error: hospitals is not associated to doctors!

Answer 1

Sie müssen Ihre Beziehung zu beiden Modelle definieren. Auch wenn Sie angleTo verwenden, sagen Sie, dass ein Arzt zu einem Krankenhaus gehört, so dass der Fremdschlüssel auf der Arzt definiert ist, ist der Fremdschlüssel in diesem Fall die ID des Krankenhauses. Aber Sie setzen den Arzt foreignKey als die ID des Krankenhauses, die nicht funktionieren wird.

module.exports = function(sequelize, DataTypes) { 
    var doctors = sequelize.define('doctors', { 
    id: { 
     type: DataTypes.INTEGER(11), 
     allowNull: false, 
     primaryKey: true, 
     autoIncrement: true 
    }, 
    name: { 
     type: DataTypes.STRING, 
     allowNull: false 
    }, 
    lastName: { 
     type: DataTypes.STRING, 
     allowNull: false 
    }, 
    SSN: { 
     type: DataTypes.STRING, 
     allowNull: false 
    }, 
    idData: { 
     type: DataTypes.INTEGER(11), 
     allowNull: false, 
     references: { // I'd recommend using the associate functions instead of creating references on the property, only causes confusion from my experience. 
     model: 'data', 
     key: 'id' 
     } 
    }, 
    speciality: { 
     type: DataTypes.ENUM('Doctor','Geriatrician'), 
     allowNull: false 
    }, 
    // This is the foreignKey property which is referenced in the associate function on BOTH models. 
    idHospital: { 
     type: DataTypes.INTEGER(11), 
     allowNull: false // Using allowNull makes this relationship required, on your model, a doctor can't exist without a hospital. 
    }, 
    }, { 
    tableName: 'doctor', 
    freezeTableName: true, 
    classMethods: { 
     associate: models => { 
     doctors.belongsTo(models.hospitals, { 
      foreignKey: "idHospital" 
     }) 
     } 
    } 
    }); 

    return doctors; 
}; 

module.exports = function(sequelize, DataTypes) { 
    var hospital = sequelize.define('hospitals', { 
    id: { 
     type: DataTypes.INTEGER(11), 
     allowNull: false, 
     primaryKey: true, 
     autoIncrement: true 
    }, 
    name: { 
     type: DataTypes.STRING, 
     allowNull: false 
    }, 
    idData: { 
     type: DataTypes.INTEGER(11), 
     allowNull: false, 
     references: { 
     model: 'data', 
     key: 'id' 
     } 
    }, 
    }, { 
    tableName: 'hospitals', 
    freezeTableName: true, 
    classMethods: { 
     associate: models => { 
      hospital.hasMany(models.doctors, { 
       foreignKey: 'idHospital' 
      } 
     } 
    } 
    }); 

    return hospital; 
}; 

UPDATE

Die Datei, die Sie Ihre Modelle zu laden verwenden, um eine Menge Code fehlt, die sequelize Arbeit machen erforderlich ist. Sie müssen die Associate-Funktion für jedes Modell manuell aufrufen. Es gibt eine Standardimplementierung, die Sequelize bietet, die ich ein bisschen geändert habe, um mit Ihrem Code zu arbeiten.

var fs = require("fs"); 
var path = require("path"); 
var Sequelize = require("sequelize"); 

module.exports = (connection) => { 
    var models = {}; 

    // Here we read in all the model files in your models folder. 
    fs 
     // This assumes this file is in the same folder as all your 
     // models. Then you can simply do require('./modelfoldername') 
     // to get all your models. 
     .readdirSync(__dirname) 
     // We don't want to read this file if it's in the folder. This 
     // assumes it's called index.js and removes any files with  
     // that name from the array. 
     .filter(function (file) { 
      return (file.indexOf(".") !== 0) && (file !== "index.js"); 
     }) 
     // Go through each file and import it into sequelize. 
     .forEach(function (file) { 
      var model = connection.import(path.join(__dirname, file)); 
      models[model.name] = model; 
     }); 

    // For each model we run the associate function on it so that sequelize 
    // knows that they are associated. 
    Object.keys(models).forEach(function (modelName) { 
     if ("associate" in models[modelName]) { 
      models[modelName].associate(models); 
     } 
    }); 

    models.connection = connection; 
    models.Sequelize = Sequelize; 

    return models 
} 

Answer 2

Haben Sie versucht das?

Doctors.findAll({ include: Hospitals, }); 

Medicos holen auch:

Doctors.findAll({ include: [{ model: Hospitals, include: [Medicos], }], });