Skip to content

B
BACKEND CHALLENGES
Commit d2554426 authored by Nguyễn Thị Nguyệt Quế's avatar Nguyễn Thị Nguyệt Quế
Browse files
Options

Merge branch 'feat/challenge_2_CRUD' into 'develop' 

Feat/challenge 2 crud

See merge request !2
parents aff2faee b6c64ab8
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 3965 additions and 1724 deletions
code/index.js deleted 100644 → 0
View file @ aff2faee
const express = require('express')
const app = express()
const port = 3000
app.get('/', (req, res) => {
res.send('Hello World!')
})
app.listen(port, () => {
console.log(`Example app listening on port ${port}`)
})
code/models/classes.js deleted 100644 → 0
View file @ aff2faee
const Sequelize = require('sequelize');
module.exports = function(sequelize, DataTypes) {
return sequelize.define('classes', {
id: {
type: DataTypes.UUID,
allowNull: false,
defaultValue: DataTypes.UUIDV4,
primaryKey: true
},
name: {
type: DataTypes.TEXT,
allowNull: true
},
description: {
type: DataTypes.TEXT,
allowNull: true
},
created_by: {
type: DataTypes.UUID,
allowNull: true
},
updated_by: {
type: DataTypes.UUID,
allowNull: true
},
course_id: {
type: DataTypes.UUID,
allowNull: true,
references: {
model: 'courses',
key: 'id'
}
},
status: {
type: DataTypes.STRING(50),
allowNull: true
}
}, {
sequelize,
tableName: 'classes',
schema: 'public',
timestamps: true,
indexes: [
{
name: "classes_pkey",
unique: true,
fields: [
{ name: "id" },
]
},
]
});
};
code/models/courses.js deleted 100644 → 0
View file @ aff2faee
const Sequelize = require('sequelize');
module.exports = function(sequelize, DataTypes) {
return sequelize.define('courses', {
id: {
type: DataTypes.UUID,
allowNull: false,
defaultValue: DataTypes.UUIDV4,
primaryKey: true
},
name: {
type: DataTypes.TEXT,
allowNull: true
},
description: {
type: DataTypes.TEXT,
allowNull: true
},
created_by: {
type: DataTypes.UUID,
allowNull: true
},
status: {
type: DataTypes.STRING(50),
allowNull: true
}
}, {
sequelize,
tableName: 'courses',
schema: 'public',
timestamps: true,
indexes: [
{
name: "courses_pkey",
unique: true,
fields: [
{ name: "id" },
]
},
]
});
};
code/models/enrollments.js deleted 100644 → 0
View file @ aff2faee
const Sequelize = require('sequelize');
module.exports = function(sequelize, DataTypes) {
return sequelize.define('enrollments', {
id: {
type: DataTypes.UUID,
allowNull: false,
defaultValue: DataTypes.UUIDV4,
primaryKey: true
},
user_id: {
type: DataTypes.UUID,
allowNull: true,
references: {
model: 'users',
key: 'id'
}
},
class_id: {
type: DataTypes.UUID,
allowNull: true,
references: {
model: 'classes',
key: 'id'
}
},
status: {
type: DataTypes.STRING(50),
allowNull: true
}
}, {
sequelize,
tableName: 'enrollments',
schema: 'public',
timestamps: true
});
};
code/models/init-models.js deleted 100644 → 0
View file @ aff2faee
var DataTypes = require("sequelize").DataTypes;
var _classes = require("./classes");
var _courses = require("./courses");
var _enrollments = require("./enrollments");
var _roles = require("./roles");
var _user_auth = require("./user_auth");
var _users = require("./users");
function initModels(sequelize) {
var classes = _classes(sequelize, DataTypes);
var courses = _courses(sequelize, DataTypes);
var enrollments = _enrollments(sequelize, DataTypes);
var roles = _roles(sequelize, DataTypes);
var user_auth = _user_auth(sequelize, DataTypes);
var users = _users(sequelize, DataTypes);
enrollments.belongsTo(classes, { as: "class", foreignKey: "class_id"});
classes.hasMany(enrollments, { as: "enrollments", foreignKey: "class_id"});
classes.belongsTo(courses, { as: "course", foreignKey: "course_id"});
courses.hasMany(classes, { as: "classes", foreignKey: "course_id"});
users.belongsTo(roles, { as: "role", foreignKey: "role_id"});
roles.hasMany(users, { as: "users", foreignKey: "role_id"});
enrollments.belongsTo(users, { as: "user", foreignKey: "user_id"});
users.hasMany(enrollments, { as: "enrollments", foreignKey: "user_id"});
user_auth.belongsTo(users, { as: "user", foreignKey: "user_id"});
users.hasMany(user_auth, { as: "user_auths", foreignKey: "user_id"});
return {
classes,
courses,
enrollments,
roles,
user_auth,
users,
};
}
module.exports = initModels;
module.exports.initModels = initModels;
module.exports.default = initModels;
code/models/roles.js deleted 100644 → 0
View file @ aff2faee
const Sequelize = require('sequelize');
module.exports = function(sequelize, DataTypes) {
return sequelize.define('roles', {
id: {
type: DataTypes.UUID,
allowNull: false,
defaultValue: DataTypes.UUIDV4,
primaryKey: true
},
name: {
type: DataTypes.TEXT,
allowNull: false
},
description: {
type: DataTypes.TEXT,
allowNull: true
},
created_by: {
type: DataTypes.UUID,
allowNull: true
}
}, {
sequelize,
tableName: 'roles',
schema: 'public',
timestamps: true,
indexes: [
{
name: "roles_pkey",
unique: true,
fields: [
{ name: "id" },
]
},
]
});
};
code/models/user_auth.js deleted 100644 → 0
View file @ aff2faee
const Sequelize = require('sequelize');
module.exports = function(sequelize, DataTypes) {
return sequelize.define('user_auth', {
id: {
type: DataTypes.UUID,
allowNull: false,
defaultValue: DataTypes.UUIDV4,
primaryKey: true
},
user_id: {
type: DataTypes.UUID,
allowNull: true,
references: {
model: 'users',
key: 'id'
}
},
password_hash: {
type: DataTypes.TEXT,
allowNull: true
}
}, {
sequelize,
tableName: 'user_auth',
schema: 'public',
timestamps: true,
indexes: [
{
name: "user_auth_pkey",
unique: true,
fields: [
{ name: "id" },
]
},
]
});
};
code/models/users.js deleted 100644 → 0
View file @ aff2faee
const Sequelize = require('sequelize');
module.exports = function(sequelize, DataTypes) {
return sequelize.define('users', {
id: {
type: DataTypes.UUID,
allowNull: false,
defaultValue: DataTypes.UUIDV4,
primaryKey: true
},
name: {
type: DataTypes.TEXT,
allowNull: false
},
date_of_birth: {
type: DataTypes.DATE,
allowNull: true
},
phone: {
type: DataTypes.TEXT,
allowNull: true
},
email: {
type: DataTypes.STRING(255),
allowNull: true
},
address: {
type: DataTypes.TEXT,
allowNull: true
},
role_id: {
type: DataTypes.UUID,
allowNull: true,
references: {
model: 'roles',
key: 'id'
}
}
}, {
sequelize,
tableName: 'users',
schema: 'public',
timestamps: true,
indexes: [
{
name: "users_pkey",
unique: true,
fields: [
{ name: "id" },
]
},
]
});
};
code/package-lock.json deleted 100644 → 0
View file @ aff2faee
This diff is collapsed.
code/package.json
View file @ d2554426
{ {
"name": "code", "name": "be-challenge",
"version": "1.0.0", "version": "1.0.0",
"description": "", "description": "",
"license": "ISC", "author": "PhamQuangBao",
"author": "",
"type": "commonjs", "type": "commonjs",
"main": "index.js", "main": "./src/index.ts",
"scripts": { "scripts": {
"test": "echo \"Error: no test specified\" && exit 1" "dev": "tsx ./src/scripts/database-gen.ts && tsx ./src/scripts/swagger-gen.ts && tsx watch ./src/index.ts",
"test": "echo \"Error: no test specified\" && exit 1",
"gen:db": "tsx src/scripts/database-gen.ts",
"gen:swagger": "tsx src/scripts/swagger-gen.ts"
},
"imports": {
"#models/*": "./src/models/*",
"#controllers/*": "./src/controllers/*",
"#services/*": "./src/services/*",
"#providers/*": "./src/providers/*",
"#docs/*": "./src/docs/*"
}, },
"dependencies": { "dependencies": {
"express": "^5.2.1", "express": "^5.2.1",
"express-automatic-routes": "^1.1.0",
"module-alias": "^2.3.4",
"pg": "^8.20.0", "pg": "^8.20.0",
"pg-hstore": "^2.3.4", "pg-hstore": "^2.3.4",
"sequelize": "^6.37.8", "sequelize": "^6.37.8",
"sequelize-auto": "^0.8.8" "sequelize-auto": "^0.8.8",
"swagger-jsdoc": "^6.2.8",
"swagger-ui-express": "^5.0.1"
},
"devDependencies": {
"@types/express": "^5.0.6",
"@types/node": "^25.7.0",
"@types/swagger-jsdoc": "^6.0.4",
"@types/swagger-ui-express": "^4.1.8",
"ts-node": "^10.9.2",
"tsx": "^4.21.0",
"typescript": "^6.0.3"
} }
} }
\ No newline at end of file
code/pnpm-lock.yaml 0 → 100644
View file @ d2554426
This diff is collapsed.
code/src/controllers/api/v1.0/classes/index.ts 0 → 100644
View file @ d2554426
import type { Application } from "express";
import type { Resource } from "express-automatic-routes";
import { ClassesProvider } from "#providers/ClassesProvider";
export default (_express: Application) => {
const classesProvider = new ClassesProvider();
return <Resource>{
/**
* @openapi
* /api/v1.0/classes:
* get:
* tags: [Classes]
* parameters:
* - $ref: '#/components/parameters/filters'
* - $ref: '#/components/parameters/sort'
* - $ref: '#/components/parameters/page'
* - $ref: '#/components/parameters/pageSize'
* responses:
* 200:
* description: Trả về danh sách lớp học thành công
* content:
* application/json:
* schema:
* type: array
* items:
* $ref: "#/components/schemas/Class"
*/
get: {
handler: async (req, res) => {
try {
const { filters, sort, page, pageSize } = req.query;
const classes = await classesProvider.getAllClasses({
filters: filters as string,
sort: sort as string,
page: page ? parseInt(page as string) : 1,
pageSize: pageSize ? parseInt(pageSize as string) : 10
});
return res.json(classes);
} catch (error) {
console.error('Error getting classes:', error);
return res.status(500).json({ error: (error as Error).message });
}
}
},
/**
* @openapi
* /api/v1.0/classes:
* post:
* tags: [Classes]
* description: Thêm một lớp học mới vào hệ thống
* requestBody:
* required: true
* content:
* application/json:
* schema:
* $ref: "#/components/schemas/CreateClassInput"
* responses:
* 201:
* description: Tạo lớp học mới thành công
* content:
* application/json:
* schema:
* $ref: "#/components/schemas/Class"
* 400:
* description: Dữ liệu đầu vào không hợp lệ (Thiếu trường, sai định dạng)
* 500:
* description: Lỗi hệ thống phía Server
*/
post: {
handler: async (req, res) => {
try {
const newClass = await classesProvider.createClass(req.body);
return res.status(201).json(newClass);
} catch (error) {
console.error('Error creating class:', error);
return res.status(400).json({ error: (error as Error).message });
}
}
}
};
};
\ No newline at end of file
code/src/controllers/api/v1.0/classes/{id}.ts 0 → 100644
View file @ d2554426
import type { Application } from "express";
import type { Resource } from "express-automatic-routes";
import { ClassesProvider } from "#providers/ClassesProvider.js";
export default (_express: Application) => {
const classesProvider = new ClassesProvider();
return <Resource>{
/**
* @openapi
* /api/v1.0/classes/{id}:
* get:
* tags: [Classes]
* parameters:
* - name: id
* in: path
* required: true
* description: Class ID
* schema:
* type: string
* responses:
* 200:
* description: Trả về thông tin lớp học thành công
* content:
* application/json:
* schema:
* type: array
* items:
* $ref: "#/components/schemas/Class"
*/
get: {
handler: async (req, res) => {
const { id } = req.params;
if (!id || typeof id !== 'string') {
return res.status(400).json({ error: "ID không hợp lệ!" });
}
try {
const classData = await classesProvider.getClassById(id);
return res.json(classData);
} catch (error) {
return res.status(404).json({ error: "Class not found" });
}
}
},
/**
* @openapi
* /api/v1.0/classes/{id}:
* put:
* tags: [Classes]
* parameters:
* - name: id
* in: path
* required: true
* schema:
* type: string
*
* requestBody:
* required: true
* content:
* application/json:
* schema:
* $ref: "#/components/schemas/PostMutate"
*
* responses:
* 200:
* description: Trả về thông tin lớp học thành công
* content:
* application/json:
* schema:
* type: array
* items:
* $ref: "#/components/schemas/Class"
*/
put: {
handler: async (req, res) => {
const { id } = req.params;
if (!id || typeof id !== 'string') {
return res.status(400).json({ error: "ID không hợp lệ!" });
}
try {
const classData = await classesProvider.updateClassById(id, req.body);
return res.json(classData);
} catch (error) {
return res.status(404).json({ error: "Class not found" });
}
}
},
/**
* @openapi
* /api/v1.0/classes/{id}:
* delete:
* tags: [Classes]
* parameters:
* - name: id
* in: path
* required: true
* description: Class ID
* schema:
* type: string
* requestBody:
* required: true
* responses:
* 200:
* description: Xóa lớp học thành công
*/
delete: {
handler: async (req, res) => {
const { id } = req.params;
if (!id || typeof id !== 'string') {
return res.status(400).json({ error: "ID không hợp lệ!" });
}
try {
const classData = await classesProvider.deleteClassById(id);
return res.json(classData);
} catch (error) {
return res.status(404).json({ error: "Class not found" });
}
}
}
};
};
\ No newline at end of file
code/src/controllers/api/v1.0/courses/index.ts 0 → 100644
View file @ d2554426
import type { Application } from "express";
import type { Resource } from "express-automatic-routes";
import { CoursesProvider } from "#providers/CoursesProvider.js";
export default (_express: Application) => {
const coursesProvider = new CoursesProvider();
return <Resource>{
/**
* @openapi
* /api/v1.0/courses:
* get:
* tags: [Courses]
* parameters:
* - $ref: '#/components/parameters/filters'
* - $ref: '#/components/parameters/sort'
* - $ref: '#/components/parameters/page'
* - $ref: '#/components/parameters/pageSize'
* responses:
* 200:
* description: Trả về danh sách khóa học thành công
* content:
* application/json:
* schema:
* type: array
* items:
* $ref: "#/components/schemas/Course"
*/
get: {
handler: async (req, res) => {
try {
const { filters, sort, page, pageSize } = req.query;
const courses = await coursesProvider.getAllCourses({
filters: filters as string,
sort: sort as string,
page: page ? parseInt(page as string) : 1,
pageSize: pageSize ? parseInt(pageSize as string) : 10
});
return res.json(courses);
} catch (error) {
console.error('Error getting courses:', error);
return res.status(500).json({ error: (error as Error).message });
}
}
},
/**
* @openapi
* /api/v1.0/courses:
* post:
* tags: [Courses]
* description: Thêm một khóa học mới vào hệ thống
* requestBody:
* required: true
* content:
* application/json:
* schema:
* $ref: "#/components/schemas/CreateCourseInput"
* responses:
* 201:
* description: Tạo khóa học mới thành công
* content:
* application/json:
* schema:
* type: array
* items:
* $ref: "#/components/schemas/Course"
*/
post: {
handler: async (req, res) => {
try {
const newCourse = await coursesProvider.createCourse(req.body);
return res.status(201).json(newCourse);
} catch (error) {
console.error('Error creating course:', error);
return res.status(400).json({ error: (error as Error).message });
}
}
}
};
};
\ No newline at end of file
code/src/controllers/api/v1.0/courses/{id}.ts 0 → 100644
View file @ d2554426
import type { Application } from "express";
import type { Resource } from "express-automatic-routes";
import { CoursesProvider } from "#providers/CoursesProvider.js";
export default (_express: Application) => {
const coursesProvider = new CoursesProvider();
return <Resource>{
/**
* @openapi
* /api/v1.0/courses/{id}:
* get:
* tags: [Courses]
* parameters:
* - name: id
* in: path
* required: true
* schema:
* type: string
*
* responses:
* 200:
* description: Trả về thông tin khóa học thành công
* content:
* application/json:
* schema:
* type: array
* items:
* $ref: "#/components/schemas/Course"
*/
get: {
handler: async (req, res) => {
const id = req.params.id;
if (!id || typeof id !== 'string') {
return res.status(400).json({ error: "ID không hợp lệ!" });
}
const course = await coursesProvider.getCourseById(id);
return res.json(course);
}
},
/**
* @openapi
* /api/v1.0/courses/{id}:
* put:
* tags: [Courses]
* parameters:
* - name: id
* in: path
* required: true
* schema:
* type: string
*
* requestBody:
* required: true
* content:
* application/json:
* schema:
* $ref: "#/components/schemas/CreateCourseInput"
*
* responses:
* 200:
* description: Trả về thông tin khóa học thành công
* content:
* application/json:
* schema:
* type: array
* items:
* $ref: "#/components/schemas/Course"
*/
put: {
handler: async (req, res) => {
const { id } = req.params;
if (!id || typeof id !== 'string') {
return res.status(400).json({ error: "ID không hợp lệ!" });
}
try {
const updateCourse = await coursesProvider.updateCourse(id, req.body);
return res.json(updateCourse);
} catch (error) {
return res.status(500).json({ error: "Lỗi khi cập nhật khóa học!" });
}
}
},
/**
* @openapi
* /api/v1.0/courses/{id}:
* delete:
* tags: [Courses]
* parameters:
* - name: id
* in: path
* required: true
* schema:
* type: string
*
* responses:
* 200:
* description: Xóa khóa học thành công
* content:
* application/json:
* schema:
* type: array
* items:
* $ref: "#/components/schemas/Course"
*/
delete: {
handler: async (req, res) => {
const { id } = req.params;
if (!id || typeof id !== 'string') {
return res.status(400).json({ error: "ID không hợp lệ!" });
}
try {
const deletedCourse = await coursesProvider.deleteCourse(id);
return res.json(deletedCourse);
} catch (error) {
return res.status(500).json({ error: "Lỗi khi xóa khóa học!" });
}
}
}
};
};
\ No newline at end of file
code/src/docs/swagger/swagger-output.json 0 → 100644
View file @ d2554426
This diff is collapsed.
code/src/index.ts 0 → 100644
View file @ d2554426
import express from 'express';
import { resolve } from 'path';
import _autoroutes from 'express-automatic-routes';
import swaggerUi from 'swagger-ui-express';
import swaggerFile from '#/docs/swagger/swagger-output.json';
const app = express()
const port = 3000
app.use(express.json());
_autoroutes(app, {
dir: resolve(__dirname, './controllers'),
log: true
});
app.use('/swagger', swaggerUi.serve, swaggerUi.setup(swaggerFile));
app.listen(port, () => {
console.log(`Example app listening on port ${port}`)
})
code/src/models/classes.ts 0 → 100644
View file @ d2554426
import * as Sequelize from 'sequelize';
import { DataTypes, Model, Optional } from 'sequelize';
import type { courses, coursesId } from './courses';
import type { enrollments, enrollmentsId } from './enrollments';
export interface classesAttributes {
id: string;
name?: string;
description?: string;
created_at?: Date;
created_by?: string;
updated_at?: Date;
updated_by?: string;
course_id?: string;
status?: string;
}
export type classesPk = "id";
export type classesId = classes[classesPk];
export type classesOptionalAttributes = "id" | "name" | "description" | "created_at" | "created_by" | "updated_at" | "updated_by" | "course_id" | "status";
export type classesCreationAttributes = Optional<classesAttributes, classesOptionalAttributes>;
export class classes extends Model<classesAttributes, classesCreationAttributes> implements classesAttributes {
id!: string;
name?: string;
description?: string;
created_at?: Date;
created_by?: string;
updated_at?: Date;
updated_by?: string;
course_id?: string;
status?: string;
// classes hasMany enrollments via class_id
enrollments!: enrollments[];
getEnrollments!: Sequelize.HasManyGetAssociationsMixin<enrollments>;
setEnrollments!: Sequelize.HasManySetAssociationsMixin<enrollments, enrollmentsId>;
addEnrollment!: Sequelize.HasManyAddAssociationMixin<enrollments, enrollmentsId>;
addEnrollments!: Sequelize.HasManyAddAssociationsMixin<enrollments, enrollmentsId>;
createEnrollment!: Sequelize.HasManyCreateAssociationMixin<enrollments>;
removeEnrollment!: Sequelize.HasManyRemoveAssociationMixin<enrollments, enrollmentsId>;
removeEnrollments!: Sequelize.HasManyRemoveAssociationsMixin<enrollments, enrollmentsId>;
hasEnrollment!: Sequelize.HasManyHasAssociationMixin<enrollments, enrollmentsId>;
hasEnrollments!: Sequelize.HasManyHasAssociationsMixin<enrollments, enrollmentsId>;
countEnrollments!: Sequelize.HasManyCountAssociationsMixin;
// classes belongsTo courses via course_id
course!: courses;
getCourse!: Sequelize.BelongsToGetAssociationMixin<courses>;
setCourse!: Sequelize.BelongsToSetAssociationMixin<courses, coursesId>;
createCourse!: Sequelize.BelongsToCreateAssociationMixin<courses>;
static initModel(sequelize: Sequelize.Sequelize): typeof classes {
return sequelize.define('classes', {
id: {
type: DataTypes.UUID,
allowNull: false,
defaultValue: DataTypes.UUIDV4,
primaryKey: true
},
name: {
type: DataTypes.TEXT,
allowNull: true
},
description: {
type: DataTypes.TEXT,
allowNull: true
},
created_at: {
type: DataTypes.DATE,
allowNull: true,
defaultValue: Sequelize.Sequelize.fn('now')
},
created_by: {
type: DataTypes.UUID,
allowNull: true
},
updated_at: {
type: DataTypes.DATE,
allowNull: true
},
updated_by: {
type: DataTypes.UUID,
allowNull: true
},
course_id: {
type: DataTypes.UUID,
allowNull: true,
references: {
model: 'courses',
key: 'id'
}
},
status: {
type: DataTypes.STRING(50),
allowNull: true
}
}, {
tableName: 'classes',
schema: 'public',
timestamps: false,
indexes: [
{
name: "classes_pkey",
unique: true,
fields: [
{ name: "id" },
]
},
]
}) as typeof classes;
}
}
code/src/models/courses.ts 0 → 100644
View file @ d2554426
import * as Sequelize from 'sequelize';
import { DataTypes, Model, Optional } from 'sequelize';
import type { classes, classesId } from './classes';
export interface coursesAttributes {
id: string;
name?: string;
description?: string;
created_at?: Date;
created_by?: string;
status?: string;
}
export type coursesPk = "id";
export type coursesId = courses[coursesPk];
export type coursesOptionalAttributes = "id" | "name" | "description" | "created_at" | "created_by" | "status";
export type coursesCreationAttributes = Optional<coursesAttributes, coursesOptionalAttributes>;
export class courses extends Model<coursesAttributes, coursesCreationAttributes> implements coursesAttributes {
id!: string;
name?: string;
description?: string;
created_at?: Date;
created_by?: string;
status?: string;
// courses hasMany classes via course_id
classes!: classes[];
getClasses!: Sequelize.HasManyGetAssociationsMixin<classes>;
setClasses!: Sequelize.HasManySetAssociationsMixin<classes, classesId>;
addClass!: Sequelize.HasManyAddAssociationMixin<classes, classesId>;
addClasses!: Sequelize.HasManyAddAssociationsMixin<classes, classesId>;
createClass!: Sequelize.HasManyCreateAssociationMixin<classes>;
removeClass!: Sequelize.HasManyRemoveAssociationMixin<classes, classesId>;
removeClasses!: Sequelize.HasManyRemoveAssociationsMixin<classes, classesId>;
hasClass!: Sequelize.HasManyHasAssociationMixin<classes, classesId>;
hasClasses!: Sequelize.HasManyHasAssociationsMixin<classes, classesId>;
countClasses!: Sequelize.HasManyCountAssociationsMixin;
static initModel(sequelize: Sequelize.Sequelize): typeof courses {
return sequelize.define('courses', {
id: {
type: DataTypes.UUID,
allowNull: false,
defaultValue: DataTypes.UUIDV4,
primaryKey: true
},
name: {
type: DataTypes.TEXT,
allowNull: true
},
description: {
type: DataTypes.TEXT,
allowNull: true
},
created_at: {
type: DataTypes.DATE,
allowNull: true,
defaultValue: Sequelize.Sequelize.fn('now')
},
created_by: {
type: DataTypes.UUID,
allowNull: true
},
status: {
type: DataTypes.STRING(50),
allowNull: true
}
}, {
tableName: 'courses',
schema: 'public',
timestamps: false,
indexes: [
{
name: "courses_pkey",
unique: true,
fields: [
{ name: "id" },
]
},
]
}) as typeof courses;
}
}
code/src/models/enrollments.ts 0 → 100644
View file @ d2554426
import * as Sequelize from 'sequelize';
import { DataTypes, Model, Optional } from 'sequelize';
import type { classes, classesId } from './classes';
import type { users, usersId } from './users';
export interface enrollmentsAttributes {
id: string;
user_id?: string;
class_id?: string;
created_at?: Date;
status?: string;
}
export type enrollmentsPk = "id";
export type enrollmentsId = enrollments[enrollmentsPk];
export type enrollmentsOptionalAttributes = "id" | "user_id" | "class_id" | "created_at" | "status";
export type enrollmentsCreationAttributes = Optional<enrollmentsAttributes, enrollmentsOptionalAttributes>;
export class enrollments extends Model<enrollmentsAttributes, enrollmentsCreationAttributes> implements enrollmentsAttributes {
id!: string;
user_id?: string;
class_id?: string;
created_at?: Date;
status?: string;
// enrollments belongsTo classes via class_id
class!: classes;
getClass!: Sequelize.BelongsToGetAssociationMixin<classes>;
setClass!: Sequelize.BelongsToSetAssociationMixin<classes, classesId>;
createClass!: Sequelize.BelongsToCreateAssociationMixin<classes>;
// enrollments belongsTo users via user_id
user!: users;
getUser!: Sequelize.BelongsToGetAssociationMixin<users>;
setUser!: Sequelize.BelongsToSetAssociationMixin<users, usersId>;
createUser!: Sequelize.BelongsToCreateAssociationMixin<users>;
static initModel(sequelize: Sequelize.Sequelize): typeof enrollments {
return sequelize.define('enrollments', {
id: {
type: DataTypes.UUID,
allowNull: false,
defaultValue: DataTypes.UUIDV4,
primaryKey: true
},
user_id: {
type: DataTypes.UUID,
allowNull: true,
references: {
model: 'users',
key: 'id'
}
},
class_id: {
type: DataTypes.UUID,
allowNull: true,
references: {
model: 'classes',
key: 'id'
}
},
created_at: {
type: DataTypes.DATE,
allowNull: true,
defaultValue: Sequelize.Sequelize.fn('now')
},
status: {
type: DataTypes.STRING(50),
allowNull: true
}
}, {
tableName: 'enrollments',
schema: 'public',
timestamps: false
}) as typeof enrollments;
}
}
code/src/models/init-models.ts 0 → 100644
View file @ d2554426
import type { Sequelize } from "sequelize";
import { classes as _classes } from "./classes";
import type { classesAttributes, classesCreationAttributes } from "./classes";
import { courses as _courses } from "./courses";
import type { coursesAttributes, coursesCreationAttributes } from "./courses";
import { enrollments as _enrollments } from "./enrollments";
import type { enrollmentsAttributes, enrollmentsCreationAttributes } from "./enrollments";
import { roles as _roles } from "./roles";
import type { rolesAttributes, rolesCreationAttributes } from "./roles";
import { user_auth as _user_auth } from "./user_auth";
import type { user_authAttributes, user_authCreationAttributes } from "./user_auth";
import { users as _users } from "./users";
import type { usersAttributes, usersCreationAttributes } from "./users";
export {
_classes as classes,
_courses as courses,
_enrollments as enrollments,
_roles as roles,
_user_auth as user_auth,
_users as users,
};
export type {
classesAttributes,
classesCreationAttributes,
coursesAttributes,
coursesCreationAttributes,
enrollmentsAttributes,
enrollmentsCreationAttributes,
rolesAttributes,
rolesCreationAttributes,
user_authAttributes,
user_authCreationAttributes,
usersAttributes,
usersCreationAttributes,
};
export function initModels(sequelize: Sequelize) {
const classes = _classes.initModel(sequelize);
const courses = _courses.initModel(sequelize);
const enrollments = _enrollments.initModel(sequelize);
const roles = _roles.initModel(sequelize);
const user_auth = _user_auth.initModel(sequelize);
const users = _users.initModel(sequelize);
enrollments.belongsTo(classes, { as: "class", foreignKey: "class_id"});
classes.hasMany(enrollments, { as: "enrollments", foreignKey: "class_id"});
classes.belongsTo(courses, { as: "course", foreignKey: "course_id"});
courses.hasMany(classes, { as: "classes", foreignKey: "course_id"});
users.belongsTo(roles, { as: "role", foreignKey: "role_id"});
roles.hasMany(users, { as: "users", foreignKey: "role_id"});
enrollments.belongsTo(users, { as: "user", foreignKey: "user_id"});
users.hasMany(enrollments, { as: "enrollments", foreignKey: "user_id"});
user_auth.belongsTo(users, { as: "user", foreignKey: "user_id"});
users.hasMany(user_auth, { as: "user_auths", foreignKey: "user_id"});
return {
classes: classes,
courses: courses,
enrollments: enrollments,
roles: roles,
user_auth: user_auth,
users: users,
};
}
code/src/models/roles.ts 0 → 100644
View file @ d2554426
import * as Sequelize from 'sequelize';
import { DataTypes, Model, Optional } from 'sequelize';
import type { users, usersId } from './users';
export interface rolesAttributes {
id: string;
name: string;
description?: string;
created_at?: Date;
created_by?: string;
}
export type rolesPk = "id";
export type rolesId = roles[rolesPk];
export type rolesOptionalAttributes = "id" | "description" | "created_at" | "created_by";
export type rolesCreationAttributes = Optional<rolesAttributes, rolesOptionalAttributes>;
export class roles extends Model<rolesAttributes, rolesCreationAttributes> implements rolesAttributes {
id!: string;
name!: string;
description?: string;
created_at?: Date;
created_by?: string;
// roles hasMany users via role_id
users!: users[];
getUsers!: Sequelize.HasManyGetAssociationsMixin<users>;
setUsers!: Sequelize.HasManySetAssociationsMixin<users, usersId>;
addUser!: Sequelize.HasManyAddAssociationMixin<users, usersId>;
addUsers!: Sequelize.HasManyAddAssociationsMixin<users, usersId>;
createUser!: Sequelize.HasManyCreateAssociationMixin<users>;
removeUser!: Sequelize.HasManyRemoveAssociationMixin<users, usersId>;
removeUsers!: Sequelize.HasManyRemoveAssociationsMixin<users, usersId>;
hasUser!: Sequelize.HasManyHasAssociationMixin<users, usersId>;
hasUsers!: Sequelize.HasManyHasAssociationsMixin<users, usersId>;
countUsers!: Sequelize.HasManyCountAssociationsMixin;
static initModel(sequelize: Sequelize.Sequelize): typeof roles {
return sequelize.define('roles', {
id: {
type: DataTypes.UUID,
allowNull: false,
defaultValue: DataTypes.UUIDV4,
primaryKey: true
},
name: {
type: DataTypes.TEXT,
allowNull: false
},
description: {
type: DataTypes.TEXT,
allowNull: true
},
created_at: {
type: DataTypes.DATE,
allowNull: true,
defaultValue: Sequelize.Sequelize.fn('now')
},
created_by: {
type: DataTypes.UUID,
allowNull: true
}
}, {
tableName: 'roles',
schema: 'public',
timestamps: false,
indexes: [
{
name: "roles_pkey",
unique: true,
fields: [
{ name: "id" },
]
},
]
}) as typeof roles;
}
}
code/src/models/sequelize-config.ts 0 → 100644
View file @ d2554426
This diff is collapsed.
code/src/models/user_auth.ts 0 → 100644
View file @ d2554426
This diff is collapsed.
code/src/models/users.ts 0 → 100644
View file @ d2554426
This diff is collapsed.
code/src/providers/ClassesProvider.ts 0 → 100644
View file @ d2554426
This diff is collapsed.
code/src/providers/CoursesProvider.ts 0 → 100644
View file @ d2554426
This diff is collapsed.
code/src/scripts/database-gen.ts 0 → 100644
View file @ d2554426
This diff is collapsed.
code/src/scripts/swagger-gen.ts 0 → 100644
View file @ d2554426
This diff is collapsed.
code/src/templates/swagger/classes/schemas.ts 0 → 100644
View file @ d2554426
This diff is collapsed.
code/src/templates/swagger/config.ts 0 → 100644
View file @ d2554426
This diff is collapsed.
code/src/templates/swagger/courses/schemas.ts 0 → 100644
View file @ d2554426
This diff is collapsed.
code/tsconfig.json 0 → 100644
View file @ d2554426
This diff is collapsed.
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment