豪翔天下

import mongoose from 'mongoose';
var Schema = mongoose.Schema;

var UserSchema = new Schema(
    {
      name: String,
      is_active: {
        type: Boolean,
        default: false
      },
      created_at: {
        type: Date,
        default: Date.now
      },
      friends: [{	// 可以直接用.populate查出关联对象
        type: Schema.Types.ObjectId,
        ref: 'User'
      }],
      father: {
        type: mongoose.Schema.Types.ObjectId,
    		ref: 'User'
      },
      meta: Object,
      meta1: {	// 也可以这样定义Object
        name: String,
        age: Number
      },
      tags: {
        type: [String],
        index: true		// 定义某个字段为索引
      }
    }, {
      collection: "自定义collection名称",
      toJSON: {virtuals: true},
      toObject: {virtuals: true}
    }
)
UserSchema.index({name: 1, type: -1}); // 在最后指定索引

// 给Model添加查询帮助方法
UserShchema.query.byName = function(name) {
  return this.where({ name: new RegExp(name, 'i')})
};
UserSchema.find().byName('name').exec((err, animals) => {});

// 给实例添加自定义的方法
UserSchema.methods.myFunc = function() {
  mongoose.model('UserSchema')	// 在实例定义里面可以通过这个方法获取Schema Model
  return this	// this就是该实例本身
}

// 给Model添加静态方法
UserSchema.statics.findByName = function(name) {
  return this.find({name: new RegExp(name, 'i')});
}
// 或者这样定义，不要用ES6里面的=>，因为用=>无法通过this获取到Schema
UserSchema.static('findByName', function(name) { return ... });
const user = await UserSchema.findByName('name')

export default mongoose.model('User', UserSchema);

// 甚至可以不定义每个字段，直接用
mongoose.model('User', new Schema(), 'UserSchema');	

$('#exampleTable').dataTable({
  ajax: {
    url: '/getData',
    type: 'get',
    headers: {},
    data: function (data) {	// 修改或添加请求的参数，常用于自己写的搜索框
      data.searchName = 'xxxx';
    },
    dataSrc: function (res) {	// 修改接口返回的数据
     	res.data.map(item => {
        item.name = '<button>abc</button>';
      })
      return res.data;
    }
  },
  buttons: [{
    text: "Bulk Make as Completed",
    className: 'marked-as-complate-btn'
  }],
  columns: [	// 从数据源dataSrc中取哪些列进行展示
    { data: 'name' },
    { data: 'status' },
    { 
      className: 'test',	// 给某一列添加类
      data: 'id',	// 列的数据名
      orderable: true, // 是否允许排序
      render: function (data, type, row) {	// 给某一列单独添加渲染方式，而不是直接展示值
      	return '<input type="checkbox" class="form-control" value=' + row.value  +'>';
      },
      searchable: false,	// 是否允许过滤
      type: 'date',	// 设置该列的类型，例如date、num、num-fmt(比如货币等$100,000)、html-num、html-num-fmt、html、string
      visible: true,	// 设置列是否可见
      width: '20%', // 强行设置列的宽度，支持数字和CSS写法
    },
  ],
  columnDefs: [{	// 相当于批量设置columns
    targets: [0, 1],	// 多少列，这里表示第0列和第1列
    orderable: false	// 定义是否可以拖动排序
  }],
  createdRow: function (row, data, index) {
    $(row).addClass('test');
  },
  data: {},	// 以数组的方式设置初始化数据，当然一般还是用的ajax
  displayLength: 10, // 默认展示的每页的记录数
  /* dom：定义表哥的控制元素以什么样式显示
  		l - length：长度改变输入控制
  		f - filtering：过滤输入框
  		t - table：表格本身
  		i - information：信息概览元素
  		p - pagination：翻页控制元素
  		r - processing：处理中显示元素
  	Bootstrap 3的样式默认值为 
      "<'row'<'col-sm-6'l><'col-sm-6'f>>" +
      "<'row'<'col-sm-12'tr>>" +
      "<'row'<'col-sm-5'i><'col-sm-7'p>>"
  	Bootstrap 4的样式默认值为
  		"<'row'<'col-sm-12 col-md-6'l><'col-sm-12 col-md-6'f>>" +
  		"<'row'<'col-sm-12'tr>>" +
  		"<'row'<'col-sm-12 col-md-5'i><'col-sm-12 col-md-7'p>>"
  	jQuery UI的样式默认值为
  	  '<"fg-toolbar ui-toolbar ui-widget-header ui-helper-clearfix ui-corner-tl ui-corner-tr"lfr>'+
  		't'+
  		'<"fg-toolbar ui-toolbar ui-widget-header ui-helper-clearfix ui-corner-bl ui-corner-br"ip>',
  */
  dom: "<'row'<'col-sm-12 col-md-6'f>>" +
       "<'row'<'col-sm-12'tr>>" +
       "<'row'<'col-sm-12 col-md-2'l><'col-sm-12 col-md-2'i><'col-sm-12 col-md-8'p>>", // 这里分三个部分进行设置，第一个row表示标题头，第二个row表示table内容，第三个row表示底部信息栏
  drawCallback: function (settings) {	// 重新渲染完成后执行
  	var api = this.api();
    console.log( api.rows( {page:'current'} ).data() ); // 获取当前页码
  },
  info: true, // 是否显示总数信息
  language: {		// 对表格进行国际化
    emptyTable: '表中没有可用数据了',
    info: "_START_ - _END_ of _TOTAL_",	// 修改10 - 20 of 30文字
		infoEmpty: "没有记录",
    infoFiltered: "从 _MAX_ 条记录中过滤"
    lengthMenu: '每页显示 _MENU_ 条',	// show xx entries
    loadingRecords: '加载中',
    processing: '处理中',
    search: '搜索',
    zeroRecords: '没有找到符合提交的数据',
    paginate: {
   		first: '首页',
    	last: '尾页',
    	next: '下一页',
    	previous: '上一页'
  	}
  },
  lengthMenu: [10, 20, 50, 100],	// 允许用户选择每页的现实数量
  ordering: false,	// 全局控制整个列表所有列的排序功能
  paging: false,	// 是否开启分页
  /*
  分页按钮样式
  numbers：仅显示数字
  simple：只显示Previous和Next
  simple_numbers： 显示Previous、Next、总页数
  full：显示First、Previous、Next、Last
  full_number：显示First、Previous、Next、Last、总页数
  first_last_numbers：显示First、Last、总页数
  */
  pagintType: 'simple_numbers',	// 分页按钮的样式
  processing: true,	// 是否在数据加载时出现“Processing”的提示
  responsive: true,
  rowReorder: true,	// 和下面这个不同的是这个只是简单的允许拖动排序，仅仅是第一列可以拖动
  rowReorder: {	// 根据指定字段自动进行排序
    dataSrc: 'order',	// 指定排序字段
    selector: 'tr td:not(:last-child)'	// 指定可拖动的行元素，如果仅仅是'tr'，那么整行都是可以直接拖动的
  }
  scrollX: true,
  searching: false,	// 屏蔽搜索框
  serverSide: true,	// 是否服务器端分页
});

serverMiddleware: [
  '~/serverMiddleware/rate-limiter.js', // 这里定义我们编写的rate-limiter插件，针对的是所有路由，注意是路由，不是每个页面请求

  // Will register file from project api directory to handle /api/* requires
  { path: '/api', handler: '~/api/index.js' },

    // We can create custom instances too
    { path: '/static2', handler: serveStatic(__dirname + '/static2') }
]

require('dotenv').config()

module.exports = {
  development: {
    username: process.env.DB_USERNAME,
    password: null,
    database: 'database_development',
    host: '127.0.0.1',
    dialect: 'mysql',
  },
  test: {
    username: 'root',
    password: null,
    database: 'database_test',
    host: '127.0.0.1',
    dialect: 'mysql',
  },
  production: {
    username: 'root',
    password: null,
    database: 'database_production',
    host: '127.0.0.1',
    dialect: 'mysql',
  },
};

var sequelize = new Sequelize('mysql://用户名:密码@HOST:3306/数据库', {
  dialect: 'mysql',	// 如果不指定这个参数，可能会报错Dialect needs to be explicitly supplied as of v4.0.0
  logging: false	// 默认会将sql查询都输出到console.log中，设置为false可以不用输出，不输出sql语句
})

// 直接执行SQL raw queries
const records = await sequelize.query("SELECT * FROM `users`", { type: QueryTypes.SELECT });

// 定义方式零，纯typescript的方式可以使用https://github.com/RobinBuschmann/sequelize-typescript
@Column(DataType.VIRTUAL)
accessToken: string;	// 添加virtual额外的字段

@Column(DataType.JSON) data: any	// JSON字段

@Column({field: 'user_id'})
userID: number;	// 自定义字段名称

// 定义方式一，typescript方式
class PostModel extends Model {
  // 定义一些值可以让其增加typescript声明
  public id: number
  public name: string
  
  // 为typescript增加获取关联对象的方法声明
  public getUser! BelongsToGetAssociationMixin<BandModel>
  
  static initModel (sequelize: Sequelize): void {
    id: {
      autoIncrement: true,
      primaryKey: true,
      type: INTEGER
    },
    name: {
      type: STRING,
      allowNull: false,
      defaultValue: 'test',
      validate: {	// 数据校验
        is: /^[a-z]+$/i,	// 满足某个正则
        is: ["^[a-z]+$",'i'],	// 同上，只是正则用数组来写
        not: /^[a-z]+$/i,
        not: ["^[a-z]+$",'i'],
        isEmail: true,
        isUrl: true,
        isIP: true,
        isIPv4: true,
        isIPv6: true,
        isAlpha: true,
        isAlphanumeric: true,
        isNumeric: true,
        isInt: true,
        isFloat: true,
        isDecimal: true,
        isLowercase: true,
        isUppercase: true,
        notNull: true,
        isNull: true,	// 只允许null
        notEmpty: true,	// 不能是空字符串
        equals: 'specific value',
        contains: 'foo',
        notIn: [['foo', 'bar']],
        isIn: [['foo', 'bar']],
        notContains: 'bar',
        len: [2,10],
        isUUID: 4,
        isDate: true,
        isAfter: "2011-11-05",
        isBefore: "2011-11-05",
        max: 23,
        min: 23,
        isCreditCard: true,	// 是否是信用卡数字
        isEven(value) {	// 自定义校验
          if (parseInt(value) % 2 !== 0) {
            throw new Error('Only even values are allowed!');
          }
        }
      },
      isIn: {
        args: [['en', 'zh']],
        msg: "Must be English or Chinese"	// 上面的校验方式都能够自定义，但是min和max不知道为啥不行，如果是min或者max就改成用len吧
      }
    }
  }

 	static relate (): void {
    PostModel.belongsTo(UserModel, {
    	as: 'user',
      foreignKey: 'user_id'
  	})
  }
  
  @AfterUpdate
  static createUser(user: UserModel) {
    console.log(user.id);
  }

  @AfterDestroy // 软删除也是这里
  static async afterDestroy(use: UserModel) {}
}

// 定义方式二
const Post = sequelize.define('post', {
    id: {
      autoIncrement: true,
      primaryKey: true,
      type: INTEGER
    },
    name: {
      type: STRING,
      allowNull: false,
      defaultValue: 'test'
    },
    firstName: {
      type: STRING,
      field: 'first_name'	// 自定义列名称,
      comment: '列注释' // 注释仅针对MySQL、MariaDB、PostgreSQL、MSSQL
    },
  	fullName: {
      type: VIRTUAL,	// 定义virtual字段，即实际不存在数据库中的字段
      get: function (this: UserModel) {
        return this.firstName + this.name
      },
      set: function (val) {
       	this.setDataValue('name', val)
      }
    },
    date: {
      type: DATE,
      defaultValue: NOW
    },
    // unique参数的值可以是不二值或者字符串，如果多格列具有相同的字符串unique，他们会组成一个复合唯一键
    uniqueOne: { type: DataTypes.STRING,  unique: 'compositeIndex' },
    uniqueTwo: { type: DataTypes.INTEGER, unique: 'compositeIndex' },

    data: {
      type: JSON
    },
    created_at: {
      type: DATE
    }
  }, {
    indexes: [{ unique: true, fields: ['field1']}], // 也可以在最后创建索引
  	timestamps: true, // 是否自动添加createdAt和updatedAt
  	tableName: 'MyPosts'	// 自定义table name，如果不提供，sequelize会根据模型名称自动以复数形式设置表名
    paranoid: true,	// 定义该表为偏执表，即自带软删除，使用destroy能自动软删除
    deletedAt: 'mydelete', // 偏执表软删除字段默认为deletedAt，这里可以指定自定义的字段名
  	validate: {	// 基于model的校验，可以同时校验多个字段
			bothCoordsOrNone() {
        if ((this.latitude === null) !== (this.longitude === null)) {
          throw new Error('Either both latitude and longitude, or neither!');
        }
      }
		}
	}
);

// 定义模型关系
Post.associate = () => {
	Post.User = Post.belongsTo(app.model.Post)
}

User.associate = () => {
  User.hasMany(Post)
}
  
// 定义模型类方法
Post.customQuery = () => {}

// 定义模型实例方法
Post.prototype.customQuery = () => {}

// 装饰器定义
@ForeignKey(() => Person)
@Column
authorId: number;
@BelongsTo(() => Person)
author: Person;

@BelongsTo(() => Person, 'person_id')	// 指定外键
author: Person;

Post.User = Post.belongsTo(app.model.Post, { foreignKey: 'post_id', as: 'Post' }),
Post.PostOwn = User.belongsTo(app.model.Post, {'foreignKey': 'id', as: 'PostOwn'})	// 如果要与当前表自身做join等操作，那么也需要定义一个与自身的关联
PostModel.belongsTo(UserModel)

// hasOne自动添加的方法
fooInstance.getBar()
fooInstance.setBar()
fooInstance.createBar()

// 例如一个用户有多篇文章，多辆车，一篇文章或者一辆车也能同时属于多个用户，那么就有这么几张表: Car, Post, User, UserThings关联表
CarModel.belongsToMany(UserModel, {
  through: {
    model: UserThingModel,	// 中间表
    unique: false,	// 如果unique为true，那么表示只有一个
    scope: {
      targetType: 'car',	// 当关联的是car时，其`target_type`字段为car
    },
    foreighKey: 'target_id',
    constraints: false
  }
})

PostModel.belongsToMany(UserModel, {
  through: {
    model: UserThingModel,	// 中间表
    unique: false,	// 如果unique为true，那么表示只有一个
    scope: {
      targetType: 'post',	// 当关联的是post时，其`target_type`字段为post
    },
    foreighKey: 'target_id',
    constraints: false
  }
})

const user = await User.create({ firstName: "Jane", lastName: "Doe" });

// 批量创建
const captains = await Captain.bulkCreate([
  { name: 'Jack Sparrow' },
  { name: 'Davy Jones' }
]);

await User.findOrCreate({
  where:{},	// 比较的字段
  defaults: {}	// 填入的字段
})