2017-10-05 9 views
4

저는 Node.js 및 MongoDB와 함께 돛 웹 프레임 워크를 사용하여 자체 웹 사이트를 만들고 있습니다. 지금 당장, 새로운 사용자를 만들려고 할 때 몇 가지 어려움에 직면 해 있으며, 게시물 요청을 보낼 때 여러 가지 유형 (숫자, 배열, 객체)의 값을 내 '사용자'컬렉션에 삽입합니다. 숫자를 '예'로 변경하고 우편 배달부를 통해 게시물 요청을 보내면 여기에서 작동하는 유일한 유형은 '문자열'입니다.이 메시지는 팝업되는 오류입니다 :다른 형식의 값을 Node.js의 MongoDB 컬렉션에 삽입하십시오.

"message": "Resolver error: \"age\" has wrong type", 
    "name": "PARAMETER_WRONG_TYPE", 

이 는 사용자의 컨트롤러입니다 :

create: function(req, res){ 
      var expectedInputs = [ 
      { 
       name: 'idsid', 
       type: 'string', 
       required: true 
      } 
      , 
      { 
       name: 'age', 
       type: 'Number', 
       required: true 
      } 
      , 
      { 
       name: 'last_name', 
       type: 'string', 
       required: true 
      } 
           ]; 

SanitizeService.allReqParams(req.allParams(), expectedInputs) 
       .then(function(sanitizedInputs){ 
        var user = {}; 
        user.idsid = sanitizedInputs['idsid']; 
        user.age = sanitizedInputs['age']; 
        user.last_name = sanitizedInputs['last_name']; 

        return UserService.create(user); 
       }) 
       .then(function(response){ 
        res.ok(response); 
       }) 
       .catch(function(err){ 
        res.badRequest(err); 
       }); 

     } 

기능이 UserService에서 만든 않습니다 :

create: function(user) { 
     return new P(function(resolve, reject){ 
      sails.log.verbose('API Audit: UserService.create called'); 
      var rejection = new Error('UserService.create Error: '); 
      user.Created = new Date(); 
      user.Modified = new Date(); 
      Users.native(function(err, collection){ 
       if(err){ 
        rejection.message += 'problem connecting to collection'; 
        return reject(rejection); 
       } 
       collection.update({'idsid': user.idsid}, user, {upsert: true}, 
        function(err, results){ 
         if(err){ 
          rejection.message += err; 
          return reject(rejection); 
         } else { 
          return resolve(results); 
         } 
        } 
       ); 
      }); 
     }); 
    } 

다른 필요있는 일이 있으면 알려 주시기 바랍니다 또는 문제를 이해하는 데 도움이됩니다. 귀하의 도움에 감사드립니다!

편집 : 아래의 제안으로, 내가 유형 "정수"로 변경하기 위해 노력하고 이것이 내가 얻을 오류입니다 이 필요한 경우 잘 모르겠어요

"stack": "Error: Resolver error: wrong type \"integer\"\n at Resolver.addParameter (C:\\workspace\\node_modules\\input-resolver\\index.js:81:13)\n at C:\\workspace\\api\\services\\SanitizeService.js:57:15\n at Array.forEach (native)\n at C:\\workspace\\api\\services\\SanitizeService.js:5 

또는 하지, 그러나 이것은 입력 해결은 다음과 같습니다

function ResolverError(msg, name) { 
    this.message = msg; 
    this.name = name; 
} 

ResolverError.prototype = new Error(); 

function Resolver() { 
    this.parameters = []; 
    this.asPromise = false; 
} 

Resolver.types = ['string', 'boolean', 'number', 'object', 'array']; 

Resolver.checkType = function(param, type) { 
    return type == 'array' ? Array.isArray(param) : typeof param === type; 
}; 

Resolver.prototype.asPromise = function(asPromise) 
{ 
    this.asPromise = (typeof asPromise == 'boolean') ? asPromise : true; 
}; 

Resolver.prototype.getParameter = function(name, parent) { 
    if (!this.parameters.length) { 
    return null; 
    } 

    parent = typeof parent == 'string' && '' != parent ? parent : null; 
    for (var i = 0, len = this.parameters.length; i < len; i++) { 
    if (name === this.parameters[i].name) { 
     if (parent && parent != this.parameters[i].parent) continue; 

     return this.parameters[i]; 
    } 
    } 

    return null; 
}; 

Resolver.prototype.getAllParameters = function() { 
    return this.parameters; 
}; 

Resolver.prototype.addParameter = function(param) { 
    var checkParameter = function(param) { 
    if (typeof param != 'object') { 
     return false; 
    } 

    if (!param.name || typeof param.required != 'boolean') { 
     return false; 
    } 

    return true; 
    }; 

    if (!checkParameter(param)) { 
    throw new ResolverError(
     'Resolver error: parameter not valid', 
     'PARAMETER_NOT_VALID' 
    ); 
    } 

    var paramFound = this.getParameter(param.name, param.parent); 
    if (null !== paramFound) { 
     throw new ResolverError(
      'Resolver error: trying to overwrite "' + param.name + '" parameter', 
      'PARAMETER_OVERWRITE' 
    ); 
    } 

    var p = { 
    name: param.name, 
    required: param.required, 
    parent: null 
    }; 

    if (typeof param.type != 'undefined') { 
    if (Resolver.types.indexOf(param.type) == -1) { 
     throw new Error('Resolver error: wrong type "' + param.type + '"'); 
    } 

    p.type = param.type; 
    } 

    if (typeof param.default != 'undefined') { 
    if (p.required) { 
     throw new Error(
     'Resolver error: trying to set default value to required parameter' 
    ); 
    } 

    if (p.type && !Resolver.checkType(param.default, p.type)) { 
     throw new Error(
     'Resolver error: default value doesn\'t match the param type' 
    ); 
    } 

    p.default = param.default; 
    } 

    if (typeof param.values != 'undefined') { 
    if (!Array.isArray(param.values)) { 
     throw new Error('Resolver error: available values is not an array'); 
    } 

    if (!param.values.length) { 
     throw new Error('Resolver error: available values array is empty'); 
    } 

    p.values = param.values; 
    } 

    if (typeof param.parent == 'string') { 
    if ('' == param.parent) { 
     throw new Error(
      'Resolver error: parent property for "' + param.name + 
      '" is an empty string' 
     ); 
    } 

    var parentParam = this.getParameter(param.parent); 
    if (null !== parentParam) { 
     if (parentParam.type && parentParam.type != 'object') { 
     throw new Error(
      'Resolver error: parent for parameter "' + param.name + '"' + 
      ' is defined, but has type of "' + parentParam.type + '" instead of' + 
      ' "object"' 
     ); 
     } 

     parentParam.type = 'object'; 
     parentParam.required = true; 
    } else { 
     this.parameters.unshift({ 
     name: param.parent, 
     required: true, 
     type: 'object', 
     parent: null 
     }); 
    } 

    p.parent = param.parent; 
    } 

    this.parameters.push(p); 

    return this; 
}; 

Resolver.prototype._resolve = function(data, callback) { 
    var getKeys = function(obj) { 
    if (typeof obj != 'object') { 
     return []; 
    } 

    var keys = []; 
    for (var k in obj) { 
     keys.push(k); 
    } 

    return keys; 
    }; 

    if (!this.parameters.length) { 
    return callback(
     new ResolverError(
     'Resolver error: no parameters specified', 
     'NO_RESOLVER_PARAMETERS' 
    ) 
    ); 
    } 

    if (!getKeys(data).length) { 
    return callback(
     new ResolverError(
     'Resolver error: empty data provided', 
     'EMPTY_DATA' 
    ) 
    ); 
    } 

    var resolved = {}; 
    for (var i = 0; i < this.parameters.length; i++) { 
    var param = this.parameters[i]; 

    var parameterData = param.parent ? data[param.parent][param.name] : 
     data[param.name] 
    ; 

    if (param.required) { 
     if (typeof parameterData == 'undefined') { 
     return callback(
      new ResolverError(
      'Resolver error: "' + param.name + '" required parameter not found', 
      'NO_REQUIRED_PARAMETER' 
     ) 
     ); 
     } 
    } else { 
     if (
     typeof parameterData == 'undefined' && 
     typeof param.default == 'undefined' 
    ) { 
     continue; 
     } 

     parameterData = typeof parameterData == 'undefined' ? 
     param.default : parameterData; 
    } 

    if (
     typeof param.type == 'string' && 
     !Resolver.checkType(parameterData, param.type) 
    ) { 
     return callback(
     new ResolverError(
      'Resolver error: "' + param.name + '" has wrong type', 
      'PARAMETER_WRONG_TYPE' 
     ) 
    ); 
    } 

    if (param.values && param.values.indexOf(parameterData) == -1) { 
     return callback(
     new ResolverError(
      'Resolver error: "' + param.name + '" has wrong value', 
      'PARAMETER_WRONG_VALUE' 
     ) 
    ); 
    } 

    if (param.parent) { 
     resolved[param.parent][param.name] = parameterData; 
    } else { 
     resolved[param.name] = parameterData; 
    } 
    } 

    return callback(null, resolved); 
}; 

Resolver.prototype.resolve = function(data, callback) { 
    this._resolve(data, callback); 
}; 

Resolver.prototype.resolvePromise = function(inputData) { 
    var _this = this; 
    return new Promise(function(fulfill, reject) { 
     _this._resolve(inputData, function(err, data) { 
      if (err) return reject(err); 
      return fulfill(data); 
     }); 
    }); 
}; 

module.exports = Resolver; 

답변

2
당신은 돛을 당신으로 몽고의 DB와 상호 작용 몽고 사용해야합니다

이 프로젝트는 돛 프로젝트입니다.

세일즈 모델은 숫자 타입을 제공하지 않으며 대신 정수 및 부동 소수점 형을 제공합니다. 돛 모델에서 지원

데이터 유형은 다음과 같습니다

  • 문자열
  • 텍스트
  • 정수
  • 플로트
  • 날짜
  • 날짜
  • 부울
  • 바이너리
  • 배열
  • JSON
  • MEDIUMTEXT
  • LONGTEXT
  • OBJECTID

이를 확인하시기 바랍니다 : http://sailsjs.com/documentation/concepts/models-and-orm/attributes 당신은이 Number에서 int로 유형을 변경할 수 있습니다.

+0

이 의견에 감사드립니다. 본인의 글은이 제안에 따라 편집되었습니다. –

+0

돛을 사용하여 몽고에 사용자를 추가하는 시나리오의 코드가 복잡해지기 때문에 돛 몽고와 관련된 설명서 또는 자습서를 참조했는지 알고 싶습니다.이 링크를 참조하여 귀하의 요구 사항과 다른지 말해주십시오. 이 문서를 읽으시기 바랍니다 : http://sailsjs.com/documentation/concepts/models-and-orm :) – TGW