lqdvi/app2-api
2
0
Fork 0
Code Issues 24 Pull Requests Actions Packages Projects Releases Wiki Activity

Modelado completo final

Browse Source
This commit is contained in:
David Arranz 2019-07-05 09:06:29 +02:00
parent c6eadc5d21
commit e99c3ac003
16 changed files with 271 additions and 167 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
modules/auth/user.model.js
View File

@ -50,7 +50,7 @@ module.exports = function (sequelize, DataTypes) {
defaultValue: null,
},
}, {
tableName: 'user',
tableName: 'users',
freezeTableName: true,
timestamps: true,
});
@ -62,8 +62,10 @@ module.exports = function (sequelize, DataTypes) {
});
User.Entity = User.belongsTo(models.Entity, { foreignKey: 'entityId' });
User.Devices = User.hasMany(models.UserDevice, { foreignKey: 'userId' });
//User.Comments = User.hasMany(models.UserComment, { foreignKey: 'UserId' });
User.Comments = User.hasMany(models.Comment, { foreignKey: 'userId' });
User.EventsReservations = User.hasMany(models.EventReservation, { foreignKey: 'userId' });
User.EventsInscriptions = User.hasMany(models.EventInscription, { foreignKey: 'userId' });
// User.InscriptionsValidate = User.hasMany(models.EventIncription, { foreignkey: 'validateUserId'})
//User.Reactions = User.hasMany(models.UserReaction, { foreignKey: 'UserId' });
};

2
modules/blog/post.model.js
View File

@ -35,7 +35,7 @@ module.exports = function (sequelize, DataTypes) {
through: models.PostCategory,
foreignKey: 'postId'
});
Post.Comments = Post.hasMany(models.Comment, { foreignKey: 'postId' });
//Post.Comments = Post.hasMany(models.Comment, { foreignKey: 'postId' });
//Post.Reactions = Post.hasMany(models.PostReaction, { foreignKey: 'postId' });
//Post.User = Post.belongsTo(models.User, { foreignKey: 'userId' });
/*

62
modules/comments/comment.model.js
View File

@ -5,42 +5,62 @@ module.exports = function (sequelize, DataTypes) {
defaultValue: DataTypes.UUIDV4,
primaryKey: true
},
entityType: {
field: 'type',
type: DataTypes.STRING,
allowNull: false
entityId: {
type: DataTypes.UUID,
allowNull: false,
},
entity: {
type: DataTypes.VIRTUAL(DataTypes.UUID, ['conferenceId', 'speakerId', 'postId']),
entityName: {
type: DataTypes.STRING,
allowNull: false,
},
type: {
type: DataTypes.STRING,
allowNull: false,
},
content: {
type: DataTypes.STRING,
allowNull: false
},
user: {
type: DataTypes.VIRTUAL(DataTypes.UUID, ['userId']),
},
/*conference: {
type: DataTypes.VIRTUAL(DataTypes.UUID, ['conferenceId']),
},*/
post: {
type: DataTypes.VIRTUAL(DataTypes.UUID, ['postId']),
},
/*speaker: {
type: DataTypes.VIRTUAL(DataTypes.UUID, ['speakerId']),
},*/
entity: {
type: DataTypes.VIRTUAL,
get: function () {
const name = this.get('entityName');
const id = this.get('entityId');
let modelName = '';
switch (name) {
case 'post':
modelName = 'Post';
break;
case 'speaker':
modelName = 'Speaker'
break;
case 'event':
modelName = 'Event';
break;
default:
break;
}
return sequelize.models[modelName].findOne(id);
}
}
}, {
indexes: [{
unique: false,
fields: ['entityId']
}],
tableName: 'comments',
freezeTableName: true,
timestamps: true,
});
Comment.associate = function (models) {
Comment.User = Comment.belongsTo(models.User, { foreignKey: 'userId', constraints: false });
//Comment.Conference = Comment.belongsTo(models.Conference, { foreignKey: 'conferenceId', constraints: false });
Comment.Post = Comment.belongsTo(models.Post, { foreignKey: 'postId', constraints: false });
//Comment.Post = Comment.belongsTo(models.Post, { foreignKey: 'postId', constraints: false });
//Comment.Speaker = Comment.belongsTo(models.Speaker, { foreignKey: 'speakerId', constraints: false });
};

5
modules/entities/entity.model.js
View File

@ -20,9 +20,8 @@ module.exports = function (sequelize, DataTypes) {
through: models.EntityEntitiesTypes,
foreignKey: 'entityId'
});
Entity.Users = Entity.hasMany(models.User, {
foreignKey: 'entityId'
});
Entity.Users = Entity.hasMany(models.User, { foreignKey: 'entityId' });
Entity.EventsReservations = Entity.hasMany(models.EventReservation, { foreignKey: 'entityId' });
};
return Entity;
};

24
modules/events/event.model.js
View File

@ -64,9 +64,6 @@ module.exports = function (sequelize, DataTypes) {
type: DataTypes.UUID,
foreignKey: true,
},
schedule: {
type: DataTypes.TEXT,
},
venueId: {
type: DataTypes.UUID,
foreignKey: true,
@ -80,9 +77,8 @@ module.exports = function (sequelize, DataTypes) {
url_registration: {
type: DataTypes.STRING,
},
user_id: {
type: DataTypes.UUID,
foreignKey: true,
marketingList: {
type: DataTypes.STRING,
},
}, {
tableName: 'events',
@ -96,16 +92,12 @@ module.exports = function (sequelize, DataTypes) {
Event.UserCreate = Event.belongsTo(models.User, { foreignKey: 'userId' });
Event.Venue = Event.belongsTo(models.Venue, { foreignKey: 'venueId' });
Event.Speakers = Event.belongsToMany(models.Speaker, {
through: models.EventSpeaker,
foreignKey: 'eventId'
});
Event.Multimedias = Event.belongsToMany(models.MultimediaFile, {
through: models.MultimediaEvent,
foreignKey: 'eventId',
otherKey: 'type'
});
Event.Schedule = Event.hasMany(models.EventSchedule, { foreignKey: 'eventId' });
Event.EventReservations = Event.hasMany(models.EventReservation, { foreignKey: 'eventId' });
Event.EventInscriptions = Event.hasMany(models.EventInscription, { foreignKey: 'eventId' });
Event.EventQuestions = Event.hasMany(models.EventQuestion, { foreignKey: 'eventId' });
//No puede haber clave foranea con entityId ya que podría repetirse ID con el caso de speakerId, un multimedia de un speaker
//Event.Multimedias = Event.hasMany(models.Multimedia, { foreignKey: 'eventId' });
};

41
modules/events/event_questions.model.js Normal file
View File

@ -0,0 +1,41 @@
'use strict';
module.exports = function (sequelize, DataTypes) {
const EventQuestion = sequelize.define('EventQuestion', {
id: {
type: DataTypes.UUID,
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
description: {
type: DataTypes.STRING,
},
anonimous: {
type: DataTypes.INTEGER,
allowNull: true
},
answered: {
type: DataTypes.INTEGER,
allowNull: true
},
discared: {
type: DataTypes.INTEGER,
allowNull: true
},
answer: {
type: DataTypes.TEXT,
},
}, {
tableName: 'events_questions',
freezeTableName: true,
timestamps: true,
});
EventQuestion.associate = function (models) {
EventQuestion.Event = EventQuestion.belongsTo(models.Event, { foreignKey: 'eventId' });
EventQuestion.Speaker = EventQuestion.belongsTo(models.Speaker, { foreignKey: 'speakerId' });
EventQuestion.UserCreate = EventQuestion.belongsTo(models.User, { foreignKey: 'userId' });
};
return EventQuestion;
};

40
modules/events/event_schedule.model.js Normal file
View File

@ -0,0 +1,40 @@
'use strict';
module.exports = function (sequelize, DataTypes) {
const EventSchedule = sequelize.define('EventSchedule', {
id: {
type: DataTypes.UUID,
defaultValue: DataTypes.UUIDV4,
primaryKey: true
},
eventId: {
type: DataTypes.UUID,
allowNull: false,
},
speakerId: {
type: DataTypes.UUID,
},
order: {
type: DataTypes.INTEGER,
allowNull: false,
},
description: {
type: DataTypes.STRING,
},
}, {
indexes: [{
unique: false,
fields: ['speakerId']
}],
tableName: 'events_schedules',
freezeTableName: true,
timestamps: true,
});
EventSchedule.associate = function (models) {
EventSchedule.Event = EventSchedule.belongsTo(models.Event, { foreignKey: 'eventId' });
};
return EventSchedule;
};

25
modules/events/event_speaker.model.js
View File

@ -1,25 +0,0 @@
'use strict';
module.exports = function (sequelize, DataTypes) {
const EventSpeaker = sequelize.define('EventSpeaker', {
eventId: {
type: DataTypes.UUID,
primaryKey: true,
allowNull: false,
},
speakerId: {
type: DataTypes.UUID,
primaryKey: true,
allowNull: false,
},
order: {
type: DataTypes.INTEGER,
},
}, {
tableName: 'events_speakers',
freezeTableName: true,
timestamps: true,
});
return EventSpeaker;
};

43
modules/events/events_inscriptions.model.js Normal file
View File

@ -0,0 +1,43 @@
'use strict';
module.exports = function (sequelize, DataTypes) {
const EventInscription = sequelize.define('EventInscription', {
id: {
type: DataTypes.UUID,
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
date: {
type: DataTypes.DATE,
},
code_ticket: {
type: DataTypes.INTEGER,
},
type: {
type: DataTypes.STRING,
allowNull: false,
defaultValue: 'regular' //grupal, invitacion-regular, invitation-grupal
},
source: {
type: DataTypes.STRING, //app, web
},
marketing_memberId: {
type: DataTypes.STRING,
},
validated: {
type: DataTypes.DATE,
},
}, {
tableName: 'events_inscriptions',
freezeTableName: true,
timestamps: true,
});
EventInscription.associate = function (models) {
EventInscription.Event = EventInscription.belongsTo(models.Event, { foreignKey: 'eventId' });
EventInscription.User = EventInscription.belongsTo(models.User, { foreignKey: 'userId' });
EventInscription.UserValidate = EventInscription.belongsTo(models.User, { foreignKey: 'validateUserId' });
};
return EventInscription;
};

76
modules/events/events_reservations.model.js Normal file
View File

@ -0,0 +1,76 @@
'use strict';
module.exports = function (sequelize, DataTypes) {
const EventReservation = sequelize.define('EventReservation', {
id: {
type: DataTypes.UUID,
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
init_avalible_date: {
type: DataTypes.DATE,
},
end_avalible_date: {
type: DataTypes.DATE,
},
gmt: {
type: DataTypes.INTEGER,
defaultValue: 1,
},
state: {
type: DataTypes.STRING,
allowNull: false,
defaultValue: 'borrador'
},
assistants: {
type: DataTypes.INTEGER,
},
confirmed: {
type: DataTypes.INTEGER,
},
allow_multiple: {
type: DataTypes.BOOLEAN,
allowNull: false,
defaultValue: false,
},
multiple_limit: {
type: DataTypes.INTEGER,
},
description: {
type: DataTypes.STRING,
},
code: {
type: DataTypes.STRING,
allowNull: false,
},
color: {
type: DataTypes.STRING,
allowNull: false,
},
allow_overflow: {
type: DataTypes.BOOLEAN,
allowNull: false,
defaultValue: false,
},
overflow_event_reservationId: {
type: DataTypes.UUID,
foreignKey: true,
},
marketingList: {
type: DataTypes.STRING,
},
}, {
tableName: 'events_reservations',
freezeTableName: true,
timestamps: true,
});
EventReservation.associate = function (models) {
EventReservation.OverflowEventReservation = EventReservation.belongsTo(models.EventReservation, { foreignKey: 'overflow_event_reservationId' });
EventReservation.Entity = EventReservation.belongsTo(models.Entity, { foreignKey: 'entityId' });
EventReservation.Event = EventReservation.belongsTo(models.Event, { foreignKey: 'eventId' });
EventReservation.UserCreate = EventReservation.belongsTo(models.User, { foreignKey: 'userId' });
};
return EventReservation;
};

26
modules/multimedia/multimedia_events.model.js
View File

@ -1,26 +0,0 @@
'use strict';
module.exports = function (sequelize, DataTypes) {
const MultimediaEvent = sequelize.define('MultimediaEvent', {
multimediafileId: {
type: DataTypes.UUID,
foreignKey: true,
primaryKey: true,
},
eventId: {
type: DataTypes.UUID,
foreignKey: true,
primaryKey: true,
},
type: {
type: DataTypes.STRING,
primaryKey: true,
},
}, {
tableName: 'multimedia_events',
freezeTableName: true,
timestamps: true,
});
return MultimediaEvent;
};

7
modules/multimedia/multimedia_file.model.js
View File

@ -40,12 +40,7 @@ module.exports = function (sequelize, DataTypes) {
MultimediaFile.MultimediaType = MultimediaFile.belongsTo(models.MultimediaType, { foreignKey: 'typeId' });
MultimediaFile.UserCreate = MultimediaFile.belongsTo(models.User, { foreignKey: 'userId' });
MultimediaFile.Events = MultimediaFile.belongsToMany(models.Event, {
through: models.MultimediaEvent,
foreignKey: 'multimediafileId',
otherKey: 'type'
});
MultimediaFile.Multimedias = MultimediaFile.hasMany(models.Multimedia, { foreignKey: 'multimediafileId' });
};
return MultimediaFile;

26
modules/multimedia/multimedia_posts.js
View File

@ -1,26 +0,0 @@
'use strict';
module.exports = function (sequelize, DataTypes) {
const MultimediaPost = sequelize.define('MultimediaPost', {
multimediafileId: {
type: DataTypes.UUID,
foreignKey: true,
primaryKey: true,
},
postId: {
type: DataTypes.UUID,
foreignKey: true,
primaryKey: true,
},
type: {
type: DataTypes.STRING,
primaryKey: true,
},
}, {
tableName: 'multimedia_posts',
freezeTableName: true,
timestamps: true,
});
return MultimediaPost;
};

26
modules/multimedia/multimedia_speakers.model.js
View File

@ -1,26 +0,0 @@
'use strict';
module.exports = function (sequelize, DataTypes) {
const MultimediaSpeaker = sequelize.define('MultimediaSpeaker', {
multimediafileId: {
type: DataTypes.UUID,
foreignKey: true,
primaryKey: true,
},
speakerId: {
type: DataTypes.UUID,
foreignKey: true,
primaryKey: true,
},
type: {
type: DataTypes.STRING,
primaryKey: true,
},
}, {
tableName: 'multimedia-speakers',
freezeTableName: true,
timestamps: true,
});
return MultimediaSpeaker;
};

12
modules/multimedia/multimedias.model.js
View File

@ -1,12 +1,16 @@
'use strict';
module.exports = function (sequelize, DataTypes) {
const Multimedias = sequelize.define('Multimedias', {
const Multimedia = sequelize.define('Multimedia', {
id: {
type: DataTypes.UUID,
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
multimediafileId: {
type: DataTypes.UUID,
allowNull: false,
},
entityId: {
type: DataTypes.UUID,
allowNull: false,
@ -54,7 +58,9 @@ module.exports = function (sequelize, DataTypes) {
timestamps: true,
});
Multimedia.associate = function (models) {
Multimedia.MultimediaFile = Multimedia.belongsTo(models.MultimediaFile, { foreignKey: 'multimediafileId' });
};
return Multimedias;
return Multimedia;
};

15
modules/speakers/speaker.model.js
View File

@ -12,7 +12,7 @@ module.exports = function (sequelize, DataTypes) {
allowNull: false,
},
description: {
type: DataTypes.STRING,
type: DataTypes.TEXT,
},
short_description: {
type: DataTypes.STRING,
@ -29,7 +29,7 @@ module.exports = function (sequelize, DataTypes) {
youtube: {
type: DataTypes.STRING,
},
linkedlin: {
linkedin: {
type: DataTypes.STRING,
},
instagram: {
@ -47,10 +47,6 @@ module.exports = function (sequelize, DataTypes) {
type: DataTypes.UUID,
foreignKey: true,
},
user_id: {
type: DataTypes.UUID,
foreignKey: true,
},
}, {
tableName: 'speakers',
freezeTableName: true,
@ -66,11 +62,8 @@ module.exports = function (sequelize, DataTypes) {
foreignKey: 'speakerId'
});
Speaker.Events = Speaker.belongsToMany(models.Event, {
through: models.EventSpeaker,
foreignKey: 'speakerId'
});
Speaker.EventSchedules = Speaker.hasMany(models.EventSchedule, { foreignKey: 'speakerId' });
Speaker.EventQuestions = Speaker.hasMany(models.EventQuestion, { foreignKey: 'speakerId' });
/*
Speaker.Multimedias = Speaker.belongsToMany(models.MultimediaFile, {
through: models.MultimediaSpeaker,