module.exports = function (sequelize, DataTypes) {
return sequelize.define('token', {
id: {
type: Sequelize.INTEGER,
primaryKey: true,
autoIncrement: true
},
content: {
type: Sequelize.STRING(20)
},
status: {
type: Sequelize.STRING(20),
defaultValue: 'active'
},
executedDate: {
type: Sequelize.DATE
},
grade: {
type: Sequelize.STRING(20)
},
reachedPoints: {
type: Sequelize.DECIMAL(6,3)
}
});
};
module.exports = function(sequelize){
var Topics = sequelize.define('topics',{
topic_id: {
type: Sequelize.BIGINT.UNSIGNED,
primaryKey: true,
autoIncrement: true
},
topic_name: {
type: Sequelize.STRING(100),
allowNull: false
},
topic_courseID:{
type: Sequelize.STRING(50)
},
topic_desc:{
type: Sequelize.TEXT,
},
topic_video:{
type: Sequelize.STRING(500)
}},
{
timestamps: false,
freezeTableName: true,
tableName: 'tblTopic'
},
{
classMethods: {
associate: function(models){
Topic.belongTo(models.Course, {foreignKey:'topic_courseID', targetKey: 'topic_id'});
}
}
});
return Topics;
}
it('should specify string length', () => {
let Simple = sequelize.define('simple', {
title: Sequelize.STRING,
tinyTitle: Sequelize.TEXT('tiny'),
mediumTitle: Sequelize.TEXT('medium'),
longTitle: Sequelize.TEXT('long'),
password: {
type: Sequelize.STRING(100)
},
secret: Sequelize.STRING(40)
});
let def = definition(Simple);
expect(def.properties.title).to.exist;
expect(def.properties.title.maxLength).to.equal(255);
expect(def.properties.tinyTitle).to.exist;
expect(def.properties.tinyTitle.maxLength).to.equal(255);
expect(def.properties.mediumTitle).to.exist;
expect(def.properties.mediumTitle.maxLength).to.equal(16777215);
expect(def.properties.longTitle).to.exist;
expect(def.properties.longTitle.maxLength).to.equal(4294967295);
expect(def.properties.password).to.exist;
expect(def.properties.password.maxLength).to.equal(100);
expect(def.properties.secret).to.exist;
expect(def.properties.secret.maxLength).to.equal(40);
});
module.exports = function(sequelize) {
var Category = sequelize.define('categories', {
cate_id: {
type: Sequelize.BIGINT(20).UNSIGNED,
allowNull: false,
autoIncrement: true,
primaryKey: true
},
cate_name: {
type: Sequelize.STRING(100),
allowNull: false
},
cate_desc: {
type: Sequelize.STRING(500),
allowNull: true
},
cate_parent: {
type: Sequelize.BIGINT(20).UNSIGNED,
allowNull: true,
defaultValue: 0
}
},{
timestamps: false,
freezeTableName: true, // Model tableName will be the same as the model name
tableName: 'tblCategory'
});
return Category;
}
module.exports = function (app) {
const sequelizeClient = app.get('sequelizeClient');
const users = sequelizeClient.define('Users', {
userId: {
type: Sequelize.UUID,
allowNull: false,
unique: true,
primaryKey: true
},
username: {
type: Sequelize.STRING(64),
allowNull: false,
unique: true
},
email : {
type: Sequelize.STRING(64),
allowNull: false,
unique: true
}
}, {
hooks: {
beforeCount(options) {
options.raw = true;
}
},
timestamps: false
});
users.associate = function (models) { // eslint-disable-line no-unused-vars
// Define associations here
// See http://docs.sequelizejs.com/en/latest/docs/associations/
};
return users;
};
constructor(){
this.EnderecoScheme = connection.define(
"address",
{
id: {
type: Sequelize.INTEGER,
primaryKey: true,
autoIncrement: true,
},
lougradouro: {
type: Sequelize.STRING(30)
},
bairro: {
type: Sequelize.STRING(20)
},
cidade: {
type: Sequelize.STRING(70)
},
cep: {
type: Sequelize.STRING(8)
}
}
);
}
module.exports = function(sequelize) {
return sequelize.define('Disciplina', {
disciplina: {
type: Sequelize.STRING(100),
allowNull: false,
unique: true,
validate: {
len: {
args: [3,100],
msg: 'O Nome da disciplina deve possuir entre 3 e 100 caracteres.'
}
}
},
sigla: {
type: Sequelize.STRING(20),
allowNull: false,
unique: true,
validate: {
len: {
args: [3,100],
msg: 'O Nome da disciplina deve possuir entre 3 e 100 caracteres.'
}
}
}
}, {
freezeTableName: true
});
};
exports.sessions = function () {
var table = sequelizeConnect.sequelizeConn().define(
'sessions',
{
//mapping coulumns i-e datatypes, null checks etc
SessionId: {autoIncrement: true, type: sequelize.INTEGER(11), allowNull: false, primaryKey: true},
uid: { type: sequelize.INTEGER(11), allowNull: false },
clientid: { type: sequelize.STRING, allowNull: false },
clientsecret: { type: sequelize.STRING, allowNull: false },
token: { type: sequelize.STRING, allowNull: true },
status: { type: sequelize.ENUM('ACTIVE', 'INACTIVE'), allowNull: true, defaultValue: 'ACTIVE' },
uuid: { type: sequelize.STRING(255), allowNull: true },
device_subscription_token: { type: sequelize.STRING(500), allowNull: true },
platform: { type: sequelize.STRING(50), allowNull: true },
platform_version: { type: sequelize.STRING(10), allowNull: true },
model: { type: sequelize.STRING(15), allowNull: true },
mobile: { type: sequelize.BOOLEAN, allowNull: true },
isRetina: { type: sequelize.BOOLEAN, allowNull: true },
screen_width: { type: sequelize.INTEGER(6), allowNull: true },
screen_height: { type: sequelize.INTEGER(6), allowNull: true },
useragent: {type: sequelize.STRING, allowNull: true},
created: { type: sequelize.INTEGER(11), allowNull: false },
expireTime: { type: sequelize.INTEGER(11), allowNull: false },
locationId: { type: sequelize.INTEGER(11), allowNull: true }
},
{
timestamps: false,
paranoid: true,
freezeTableName: true,
tableName: 'sessions'
}
);
return table;
};
model: function(){
return db.define('user', {
username: {
type: Sequelize.STRING(32),
allowNull: false,
validate: {
len: [ 3, 32 ]
}
},
password: {
type: Sequelize.STRING(64),
allowNull: false,
get: function(){
return this.changed('password') ? this.getDataValue('password') : null;
},
set: function(v){
return this.setDataValue('password', bcrypt.hashSync(v, 8));
}
},
apiKey: {
type: Sequelize.STRING(32),
allowNull: true
}
}, {
instanceMethods: {
isValidPassword: function(password, cb){
return bcrypt.compare(password, this.getDataValue('password'), cb);
},
setNewApiKey: function(){
return this.setDataValue('apiKey', hat());
}
},
hooks: {
beforeCreate: function(user, cb){
user.setNewApiKey();
return cb(null, user);
}
}
});
},
init: function(db) {
var E = db.define("band", {
id: {type: Sequelize.INTEGER, allowNull: false, primaryKey: true, autoIncrement: true},
name: {type: Sequelize.STRING(128), allowNull: false},
styleID: {type: Sequelize.INTEGER, allowNull: true, field : "style_id"},
creationDate: {type: Sequelize.DATEONLY, allowNull: true, field: "creation_date"},
country: {type: Sequelize.STRING(2), allowNull: true},
}, {
schema: "dbo",
tableName: "band",
timestamps: false
});
return E;
}
it('should accept a sequelize model as a response object', () => {
let model = sequelize.define('test', {
name: {
type: Sequelize.STRING(123)
}
});
let res = {
locals: { id: 1, name: 'hello' },
json: sinon.spy(),
status: sinon.stub().returnsThis()
};
let middleware = joi({
body: model
});
return Promise.resolve(
middleware({}, res)
)
.then(() => {
expect(spy).to.have.been.calledOnce;
expect(res.json).to.have.been.calledWith({ id: 1, name: 'hello' });
});
});
module.exports = function () {
var sequelize = new Sequelize(process.env.DATABASE_URL);
var UserModel = sequelize.define('User', {
name: Sequelize.STRING,
email: {
type: Sequelize.STRING(125),
allowNull: true
},
profile_image: Sequelize.TEXT,
provider_name: Sequelize.STRING,
provider_uid: Sequelize.STRING,
}, {
createdAt: 'created',
updatedAt: 'modified',
deletedAt: 'deleted',
paranoid: true,
underscored: true,
});
return {
sequelize: sequelize,
Sequelize: Sequelize,
models: {
UserModel: UserModel
}
};
}
it('should allow specifying custom status code', () => {
let model = sequelize.define('test', {
name: {
type: Sequelize.STRING(123)
}
});
let res = {
locals: { id: 1, name: 'hello' },
json: sinon.spy(),
status: sinon.stub().returnsThis()
};
let middleware = joi({
body: model,
status: 201
});
return Promise.resolve(
middleware({}, res)
)
.then(() => {
expect(spy).to.have.been.calledOnce;
expect(res.json).to.have.been.calledWith({ id: 1, name: 'hello' });
expect(res.status).to.have.been.calledWith(201);
});
});
function Init(sequelize) {
let Entity = sequelize.define('test', {
name: Sequelize.STRING(128),
a_score: Sequelize.INTEGER,
b_score: Sequelize.INTEGER,
c_score: Sequelize.INTEGER,
questions: Sequelize.JSON
},
{
instanceMethods: {
getDisplayName: function () {
return this.name;
}
}
});
Entity.belongsTo(sequelize.models["subject"]);
Entity.belongsTo(sequelize.models["user"]);
Entity.hasMany(sequelize.models['test_result'], {
foreignKey: { allowNull: false },
onDelete: 'CASCADE'
});
Entity.belongsToMany(sequelize.models["group"], { through: 'tests_groups' });
}
function Forward(db) {
if (!(this instanceof Forward)) {
return new Forward(db);
}
var $model = db.define('forward', {
source: {
type: sequelize.STRING(80),
unique: true,
primaryKey: true
},
destination: sequelize.ARRAY(sequelize.TEXT),
enable_greylisting: sequelize.BOOLEAN,
enable_policyd: sequelize.BOOLEAN
}, {
freezeTableName: true,
tableName: 'forward',
timestamps: false,
});
var self = this;
self.query = query;
self.$model = $model;
function query() {
return $model.findAll({});
}
}
module.exports = function(db) {
return db.define('Review', {
id: {
type: Sequelize.INTEGER,
allowNull: false,
autoIncrement: true,
primaryKey: true
},
rating: {
type: Sequelize.INTEGER,
allowNull: false,
defaultValue: 1
},
comment: {
type: Sequelize.STRING(500),
allowNull: true
},
authorId: {
type: Sequelize.INTEGER,
allowNull: false,
references: {
model: 'Users',
key: 'id'
}
},
propertyId: {
type: Sequelize.INTEGER,
allowNull: false,
references: {
model: 'Properties',
key: 'id'
}
}
}, {
timestamps: false,
classMethods: {
validate: function(data) {
return new BB(function(pass, fail) {
Joi.validate(data, creationSchema, function (err) {
if(!!err) {
fail(new DataValidationError("Invalid data", err));
}else {
pass(data);
}
});
});
}
},
instanceMethods: {
getFields: function() {
return _.omit(this.get({plain: true}), ['author', 'property']);
}
}
});
};
module.exports = function(sequelize){
var Lessons = sequelize.define('lessons',{
lesson_id: {
type: Sequelize.BIGINT(20).UNSIGNED,
//allowNull: false,
autoIncrement: true,
primaryKey: true
},
lesson_name: {
type: Sequelize.STRING(100),
allowNull: false
},
lesson_topicId: {
type: Sequelize.BIGINT(20).UNSIGNED,
},
lesson_desc: {
type: Sequelize.TEXT,
},
lesson_video: {
type: Sequelize.STRING(500)
},
lesson_mate:{
type: Sequelize.STRING(500)
},
lesson_type:{
type: Sequelize.INTEGER,
allowNull: false,
defaultValue: 1
},
lesson_time: {
type: Sequelize.DATE
}
},{
timestamps: false,
freezeTableName: true,
tableName: 'tblLesson'
},{
classMethods: {
associate: function(models){
Lesson.belongsTo(models.Topic, {foreignKey: 'lesson_topicId', targetKey: 'topic_id' });
}
}
});
return Lessons;
}
module.exports = function(sequelize){
var category = sequelize.define('category', {
id: {
type: Sequelize.INTEGER,
autoIncrement: true,
primaryKey: true
},
sorting: {
type: Sequelize.INTEGER,
defaultValue: -1
},
title: {
type: Sequelize.STRING(64),
unique: true
},
slug: {
type: Sequelize.STRING(64),
unique: true
}
}, {
classMethods: {
associate: function(models){
category.hasMany(models.category, {as: 'children', foreignKey: 'parentId'});
category.belongsTo(models.category, {as: 'parent', foreignKey: 'parentId'});
category.hasMany(models.post);
category.addHook('beforeFind', function(options){
if(options.modelInclude){
options.include = [{model: models.category, as: 'children'}];
}
return options;
});
}
},
setterMethods: {
title: function(title){
this.setDataValue('slug', slugify(title));
this.setDataValue('title', title);
return title;
}
}
});
return category;
}
module.exports = function(sequelize, DataTypes) {
var Device = sequelize.define('Device', {
name: {
type: Sequelize.STRING(32),
unique: true,
allowNull: false,
validate: {
notEmpty: true,
},
},
displayName: {
type: Sequelize.STRING(255),
},
});
return Device;
}
module.exports = (sequelize) => {
return sequelize.define('user', {
id: {
type: Sequelize.STRING,
primaryKey: true
},
email: {
type: Sequelize.STRING(400),
allowNull: false,
validate: {
isEmail: true,
}
},
password: {
type: Sequelize.STRING(100),
}
}, {
freezeTableName: true, // Model tableName will be the same as the model name
comment: 'user base information',
indexes: [{
unique: true,
fields: ['email'],
}],
classMethods: {
add: async function add(userInfo) {
const isExist = await this.find({ where: { email: userInfo.email }});
if (isExist) {
throw new VError(`User: ${userInfo.email} has been register`, HTTPStatus.BAD_REQUEST);
}
const salt = await bcrypt.genSalt(10);
userInfo.password = await bcrypt.hash(userInfo.password, salt);
userInfo.id = uuidV1();
const user = this.build(userInfo);
return await user.save();
},
findByEmail: async function findByEmail(email) {
return await this.find({ where: { email }});
},
findByID: async function findByID(id) {
return await this.find({ where: { id }});
}
},
});
}
module.exports=function(sequelize,DataTypes){
const Post = sequelize.define('post', {
post_id: {
type: Sequelize.INTEGER,
allowNull:false,
autoIncrement:true,
primaryKey:true
},
user_id: {
type: Sequelize.INTEGER,
allowNull:false
},
title:{
type: Sequelize.STRING(200),
allowNull:false
},
idea:{
type: Sequelize.STRING(1000),
allowNull: false
},
like_count:{
type:Sequelize.INTEGER,
allowNull:true,
default:0
}
});
Post.associate = function (models) {
models.Post.belongsTo(models.users, {
onDelete: 'CASCADE',
foreignKey: {
name: 'user_id',
allowNull: false
},
});
};
return Post;
}
module.exports = city=> {
city = city || 'bj';
return sequelize.define('shop_' + city, {
id: {
type: Sequelize.INTEGER,
autoIncrement: true,
primaryKey: true,
unique: true
},
name: Sequelize.STRING(100),
shopid: Sequelize.STRING(100),
addr: Sequelize.STRING(500),
area: Sequelize.STRING(500),
phone: Sequelize.STRING(20),
level: Sequelize.INTEGER(10),
num1: Sequelize.INTEGER(20),
num2: Sequelize.INTEGER(20)
});
};
module.exports = function(app) {
var Wine = db.define('Wine', {
id: {
type: Sequelize.INTEGER,
autoIncrement: true,
primaryKey: true,
allowNull: false
},
name: Sequelize.STRING(45),
year: Sequelize.STRING(45),
grapes: Sequelize.STRING(45),
country: Sequelize.STRING(45),
region: Sequelize.STRING(45),
description: Sequelize.BLOB,
picture: Sequelize.STRING
}
, {
tableName: 'wine',
timestamps: false
}
)
db
.sync({ force: false }) // si se pone a true borra la tabla
.complete(function (err) {
if (!!err) {
console.log('An error occurred while creating the table:', err)
} else {
console.log('It worked!')
}
})
var opciones={endpoit:'/api',allowed:new Array('Wine')}
app.use(restful(db, opciones))
}
module.exports = function(HiddenMenu, DataTypes) {
var HidenMenu = sequelize.define('user_pictures', {
user_id: { type: Sequelize.INTEGER(11)},
aws_hash: { type: Sequelize.STRING(128)}
},{
tableName: 'user_pictures'
});
return HiddenMenu
};
module.exports = function(sequelize, DataTypes) {
var RomVariant = sequelize.define('RomVariant', {
name: {
type: Sequelize.STRING(32),
unique: true,
allowNull: false,
validate: {
notEmpty: true,
},
},
subdirectory: {
type: Sequelize.STRING(255),
},
displayName: {
type: Sequelize.STRING(255),
},
});
return RomVariant;
}
it("should populate STRING(n) with random string", function (done) {
var Model = sequelize.define("Model", {
name: Sequelize.STRING(42)
});
sync().then(function () {
return new SequelizeG(Model).then(function (instance) {
assert.ok(_.isString(instance.name));
assert.ok(instance.name.length > 0);
});
}).then(done, done);
});
module.exports = function(sequelize)
{
// TrackEdit is created when Track information is changed
var TrackEdit = sequelize.define("TrackEdit",
{
editId: { type: Sequelize.INTEGER, primaryKey: true, autoIncrement: true },
artist: Sequelize.STRING(50),
title: Sequelize.STRING(50),
date: { type: Sequelize.DATE, defaultValue: Sequelize.NOW },
});
var Track = sequelize.models.Track;
Track.hasMany(TrackEdit, { foreignKey: "trackId", onDelete: "cascade" });
TrackEdit.belongsTo(Track, { foreignKey: "trackId" });
var User = sequelize.models.User;
User.hasMany(TrackEdit, { foreignKey: "userId" });
TrackEdit.belongsTo(User, { foreignKey: "userId" });
return TrackEdit;
}
module.exports = function(sequelize){
var tracking = sequelize.define('tracking', {
id: {
type: Sequelize.INTEGER,
autoIncrement: true,
primaryKey: true
},
event: {
type: Sequelize.STRING(65)
},
data: {
type: Sequelize.STRING
},
sessionId: {
type: Sequelize.STRING(48)
}
});
return tracking;
}
module.exports = function (sequelize) {
const tutorial = sequelize.define('tutorial', {
title: {
type: Sequelize.STRING,
allowNull: false
},
sourceUrl: {
type: Sequelize.STRING(2000),
validate: {
isUrl: true
}
},
sourceDomain: {
type: Sequelize.STRING
},
content: {
type: Sequelize.TEXT
},
contentHtml: {
type: Sequelize.TEXT
},
keywords: {
type: Sequelize.ARRAY(Sequelize.TEXT)
},
languages: {
type: Sequelize.ARRAY(Sequelize.TEXT)
},
platforms: {
type: Sequelize.ARRAY(Sequelize.TEXT)
},
projects: {
type: Sequelize.ARRAY(Sequelize.TEXT)
},
creator: {
type: Sequelize.STRING,
allowNull: false
},
commentsCount: {
type: Sequelize.INTEGER,
defaultValue: 0
}
}, {
timestamps: true,
paranoid: true,
freezeTableName: true
})
// tutorial.sync({
// force: true
// })
return tutorial
}
module.exports = function(sequelize) {
return sequelize.define('polyline', {
shape_id: {
type: Sequelize.STRING,
primaryKey: true,
},
polyline: Sequelize.STRING(5000)
}, {
createdAt: false,
updatedAt: false,
timestamps: false,
})
}