结果未存储在 Google 数据存储数据库中

const express = require('express');
const router = express.Router();
const { check, validationResult } = require('express-validator');
var User =require('../models/user');

//get register page
router.get('/register',function(req,res){
    res.render('register')
});

//get login page
router.get('/login',function(req,res){
    res.render('login')
});


router.post('/register',  [
        check('Name').isEmpty().withMessage('The Name is required'),
        check('Email').isEmail().withMessage('Email is requried'),
        //check('Password').isEmpty().withMessage('pass is requried'),
        //check('Password','Password is Requried').isEmpty(),
       // check('Password2','Password Not Match').equals('password2'),
 
      ], (req, res,next) => {
  const errors = validationResult(req);
  if (!errors.isEmpty()) {
    res.render('register',{
        error:errors.mapped()
    })
  }else{

    console.log()
    
    const newUser = new User ({
        firstname:req.body.name,
        lastname:req.body.name,
        email :req.body.Email,
        password :req.body.Password,
        createdOn:req.body.name
      });
      console.log("Data1",newUser)
     
        const createUser = (req, res) => {
        const entityData = User.sanitize(req.body);
        const user = new User(entityData);
        console.log("Data2",createUser)
        user.save()
            .then((entity) => {
                res.json(entity.plain()); 
            })
            .catch((err) => {
                // If there are any validation error on the schema
                // they will be in this error object
                res.status(400).json(err);
            })
    };
  
      req.flash('success_msg','you are registered and can login now');
      res.redirect('/users/login');

  }
  
});

module.exports=router;

const { Gstore, instances } = require('gstore-node');
const { Datastore } = require('@google-cloud/datastore');
 
const gstore = new Gstore();
const datastore = new Datastore({
    projectId: 'sinuous250616',
});
 
gstore.connect(datastore);
 
// Save the gstore instance
instances.set('unique-id', gstore);


const bcrypt = require('bcrypt');
 
// Retrieve the gstore instance
const ggstore = instances.get('unique-id');
const { Schema } = ggstore;
 
/**
 * A custom validation function for an embedded entity
 */
const validateAccessList = (value, validator) => {
    if (!Array.isArray(value)) {
        return false;
    }
 
    return value.some((item) => {
        const isValidIp = !validator.isEmpty(item.ip) && validator.isIP(item.ip, 4);
        const isValidHostname = !validator.isEmpty(item.hostname);
 
        return isValidHostname && isValidIp;
    });
}
 
//Create the schema for the User Model
const userSchema = new Schema({
    firstname: { type: String, required: true },
    lastname: { type: String, optional: true  },
    email: { type: String, validate: 'isEmail', required: true },
    password: { type: String, read: false, required: true },
    createdOn: { type: String, default: gstore.defaultValues.NOW, write: false, read: false }

});

/**
 * List entities query shortcut
 */
const listSettings = {
    limit: 15,
    order: { property: 'lastname' }
};
userSchema.queries('list', listSettings);
 
/**
 * Pre "save" middleware
 * Each time the entity is saved or updated, if there is a password passed, it will be hashed
*/
function hashPassword() {
    // scope *this* is the entity instance
    const _this = this;
    const password = this.password;
 
    if (!password) {
        return Promise.resolve();
    }
 
    return new Promise((resolve, reject) => {
        bcrypt.genSalt(5, function onSalt(err, salt) {
            if (err) {
                return reject(err);
            };
 
            bcrypt.hash(password, salt, null, function onHash(err, hash) {
                if (err) {
                    // reject will *not* save the entity
                    return reject(err);
                };
 
                _this.password = hash;
 
                // resolve to go to next middleware or save method
                return resolve();
            });
        });
    });

 
// add the "pre" middleware to the save method
userSchema.pre('save', hashPassword);
 
/**
 * Export the User Model
 * It will generate "User" entity kind in the Datastore
*/
module.exports = gstore.model('User', userSchema);