無法在POST json對象上讀取屬性

Question

我收到了一個錯誤

TypeError: Cannot read property 'tasks' of undefined

當我在我的api上嘗試新的POST請求時，以下是我正在嘗試的請求正文

{
    "name": "tecnica1",
    "description": "tecnica ensino1",
    "rules": ["Regra1", "Regra2"],
    "delivery_mode": ["Face to face", "Blended"],
    "interaction": ["Group based", "One to many"],
    "interrelationship": "High",
    "motivation": "High",
    "participation": ["Medium", "Low"],
    "performance": ["Low", "None"],
    "scope": ["Open ended", "Close ended"],
    "feedback_use": "Low",
    "target_audience": [15, 17],
    "learning_objectives" : [
        {
            "knowledge_category": "Factual",
            "behaviour": "Comparing",
            "subject_matter": "teste",
            "conditions": "teste",
            "degree": "teste"
        },
        {
            "knowledge_category": "Procedural",
            "behaviour": "Explaining",
            "subject_matter": "teste"
        }

    ],
    "affective_objectives": "teste",
    "social_objectives": "teste",
    "structure": {
        "modules": [{
            "name": "teste",
            "phases": [{
                "name": "teste",
                "tasks": [{
                    "type": "tipo1",
                    "description": "teste",
                    "role": "Student",
                    "resources": ["Recurso1", "Recurso2"]
                }]
            },
            {
                "name": "test2",
                "tasks": [{
                    "type": "tipo1",
                    "description": "teste",
                    "role": "Student",
                    "resources": ["Recurso1", "Recurso2"]
                },
                {
                    "type": "tipo1",
                    "description": "teste",
                    "role": "Student",
                    "resources": ["Recurso1", "Recurso2"]
                }]
            }]
        }]
    }
}

該錯誤指的是結構/模塊/階段下的嵌套對象“任務”

這是描述我試圖發布的對象的模型以及處理它的控制器函數。

Tecnica.js

const mongoose        = require('mongoose');
const Schema          = mongoose.Schema;
const idValidator     = require('mongoose-id-validator');

const EVAL  = ['High', 'Medium', 'Low', 'None']

let TaskSchema        = new Schema({

  type  : {
    type      : String,
    required  : true
  },

  description  : {
    type      : String,
    required  : true
  },

  role  : {
    type      : String,
    required  : true,
    enum      : ['Student', 'Staff']
  },

  resources : [String]

});

let PhaseSchema       = new Schema({

  name  : {
    type      : String,
    required  : true
  },

  tasks  : {
    type  : [TaskSchema],
    validate  : {
      validator: function(v){
        return v.length >= 1;
      },
      message : 'At least one task should be defined.'
    }
  }
});

let ModuleSchema      = new Schema({

  name  : {
    type      : String,
    required  : true
  },

  phases  : {
    type  : [PhaseSchema],
    validate  : {
      validator: function(v){
        return v.length >= 1;
      },
      message : 'At least one phase should be defined.'
    }
  }
});


let EstruturaTecnicaSchema   = new Schema({

  modules : {
    type      : [ModuleSchema],
    validate  : {
      validator: function(v){
        return v.length >= 1;
      },
      message : 'At least one module should be defined.'
    }
  }
});

let LearningSchema    = new Schema({
  knowledge_category : {
    type     : String,
    required : true,
    enum     : ['Factual', 'Conceptual', 'Procedural', 'Metacognitive']
  },

  behaviour : {
    type     : String,
    required : true
  },

  subject_matter : {
    type     : String,
    required : true
  },

  // Optinal/if any
  conditions  : String,
  degree      : String
});


/*
  Technique defined by:
  Init Data + Tlt Data.
  Init Data consists of name, description and set of rules.
  Tlt Data is defined by context and structure

*/
let TecnicaSchema     = new Schema({

  //Init Data
  name  : {
    type     : String,
    required : true
  },

  description  : {
    type     : String,
    required : true
  },

  rules : [String],

  //Context
  delivery_mode : {
    type     : [String],
    required : true
  },

  interaction : {
    type     : [String],
    required : true
  },

  // Perception
  // interrelationship, motivation, participation, performance

  interrelationship : {
    type     : [String],
    required : true,
    enum     : EVAL
  },

  motivation : {
    type     : [String],
    required : true,
    enum     : EVAL
  },

  participation : {
    type     : [String],
    required : true,
    enum     : EVAL
  },

  performance : {
    type     : [String],
    required : true,
    enum     : EVAL
  },

  scope : {
    type     : [String],
    required : true
  },

  feedback_use : {
    type     : [String],
    required : true,
    enum     : EVAL
  },

  target_audience : {
    type     : [Number],
    required : true
  },

  learning_objectives : {
    type      : [LearningSchema],
    validate : {
      validator: function(v){
        return v.length >= 1;
      },
      message : 'At least one learning objective should be defined.'
    }
  },

  affective_objectives : {
    type  : [String]
  },

  social_objectives : {
    type  : [String]
  },

  structure : {
    type      : EstruturaTecnicaSchema,
    required  : true
  },

  psychologist : {
    type      : mongoose.Schema.Types.ObjectId,
    ref       : 'User',
    required  : true
  }
});

TecnicaSchema.plugin(idValidator);


module.exports = mongoose.model('Tecnica', TecnicaSchema);

tecnicas.controller.js

function create(req, res) {

  let tecnica                   = new Tecnica();
  let learning_objectives       = req.body.learning_objectives;
  let structure                 = req.body.structure;
  let modules                   = req.body.structure.modules;
  let phases                    = req.body.structure.modules.phases
  let tasks                     = req.body.structure.modules.phases.tasks;

  phases.tasks                  = tasks.map(t => { return t; });
  modules.phases                = phases.map(p => { return p; });
  structure.modules             = modules.map(m => { return m; });

  tecnica.name                  = req.body.name;
  tecnica.description           = req.body.description;
  tecnica.rules                 = req.body.rules;
  tecnica.delivery_mode         = req.body.delivery_mode;
  tecnica.interaction           = req.body.interaction;
  tecnica.interrelationship     = req.body.interrelationship;
  tecnica.motivation            = req.body.motivation;
  tecnica.participation         = req.body.participation;
  tecnica.performance           = req.body.performance;
  tecnica.scope                 = req.body.scope;
  tecnica.feedback_use          = req.body.feedback_use;
  tecnica.target_audience       = req.body.target_audience;
  tecnica.learning_objectives   = learning_objectives.map(l =>  {
    return  l;
  });
  tecnica.affective_objectives  = req.body.affective_objectives;
  tecnica.social_objectives     = req.body.social_objectives;
  tecnica.structure             = req.body.structure;
  tecnica.psychologist          = req.user;

  tecnica.save()
  .then(t => {
    return res.status(201).json(t);
  })
  .catch(utils.handleError(req, res));

}

我該如何解析任務？

我已經在使用body-parser和選項了

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

Answer 1

modules ， phases ， tasks是數組。 你不能調用req.body.structure.modules.phases.tasks

req.body.structure.modules是一個數組req.body.structure.modules.phases不存在req.body.structure.modules.phases undefined 。

分配這樣的屬性的更好方法：

function create(req, res) {

  let tecnica                   = new Tecnica();
  Object.assign(tecnica, { ...req.body });
  tecnica.psychologist          = req.user;

  tecnica.save()
  .then(t => {
    return res.status(201).json(t);
  })
  .catch(utils.handleError(req, res));

}