Fix toolbar and reformat backend code

backend/src/controllers/course-requirement.controller.ts

@@ -1,110 +1,111 @@
 import {
-  Count,
-  CountSchema,
-  Filter,
-  repository,
-  Where,
+    Count,
+    CountSchema,
+    Filter,
+    repository,
+    Where,
 } from '@loopback/repository';
 import {
-  del,
-  get,
-  getModelSchemaRef,
-  getWhereSchemaFor,
-  param,
-  patch,
-  post,
-  requestBody,
+    del,
+    get,
+    getModelSchemaRef,
+    getWhereSchemaFor,
+    param,
+    patch,
+    post,
+    requestBody,
 } from '@loopback/rest';
 import {
-  Course,
-  Requirement,
+    Course,
+    Requirement,
 } from '../models';
-import {CourseRepository} from '../repositories';
+import { CourseRepository } from '../repositories';
 
 export class CourseRequirementController {
-  constructor(
-    @repository(CourseRepository) protected courseRepository: CourseRepository,
-  ) { }
+    constructor(
+        @repository(CourseRepository) protected courseRepository: CourseRepository,
+    ) {
+    }
 
-  @get('/courses/{id}/requirements', {
-    responses: {
-      '200': {
-        description: 'Array of Course has many Requirement',
-        content: {
-          'application/json': {
-            schema: {type: 'array', items: getModelSchemaRef(Requirement)},
-          },
+    @get('/courses/{id}/requirements', {
+        responses: {
+            '200': {
+                description: 'Array of Course has many Requirement',
+                content: {
+                    'application/json': {
+                        schema: {type: 'array', items: getModelSchemaRef(Requirement)},
+                    },
+                },
+            },
         },
-      },
-    },
-  })
-  async find(
-    @param.path.number('id') id: number,
-    @param.query.object('filter') filter?: Filter<Requirement>,
-  ): Promise<Requirement[]> {
-    return this.courseRepository.requirements(id).find(filter);
-  }
-
-  @post('/courses/{id}/requirements', {
-    responses: {
-      '200': {
-        description: 'Course model instance',
-        content: {'application/json': {schema: getModelSchemaRef(Requirement)}},
-      },
-    },
-  })
-  async create(
-    @param.path.number('id') id: typeof Course.prototype.id,
-    @requestBody({
-      content: {
-        'application/json': {
-          schema: getModelSchemaRef(Requirement, {
-            title: 'NewRequirementInCourse',
-            exclude: ['id'],
-            optional: ['courseId']
-          }),
-        },
-      },
-    }) requirement: Omit<Requirement, 'id'>,
-  ): Promise<Requirement> {
-    return this.courseRepository.requirements(id).create(requirement);
-  }
-
-  @patch('/courses/{id}/requirements', {
-    responses: {
-      '200': {
-        description: 'Course.Requirement PATCH success count',
-        content: {'application/json': {schema: CountSchema}},
-      },
-    },
-  })
-  async patch(
-    @param.path.number('id') id: number,
-    @requestBody({
-      content: {
-        'application/json': {
-          schema: getModelSchemaRef(Requirement, {partial: true}),
-        },
-      },
     })
-    requirement: Partial<Requirement>,
-    @param.query.object('where', getWhereSchemaFor(Requirement)) where?: Where<Requirement>,
-  ): Promise<Count> {
-    return this.courseRepository.requirements(id).patch(requirement, where);
-  }
+    async find(
+        @param.path.number('id') id: number,
+        @param.query.object('filter') filter?: Filter<Requirement>,
+    ): Promise<Requirement[]> {
+        return this.courseRepository.requirements(id).find(filter);
+    }
 
-  @del('/courses/{id}/requirements', {
-    responses: {
-      '200': {
-        description: 'Course.Requirement DELETE success count',
-        content: {'application/json': {schema: CountSchema}},
-      },
-    },
-  })
-  async delete(
-    @param.path.number('id') id: number,
-    @param.query.object('where', getWhereSchemaFor(Requirement)) where?: Where<Requirement>,
-  ): Promise<Count> {
-    return this.courseRepository.requirements(id).delete(where);
-  }
+    @post('/courses/{id}/requirements', {
+        responses: {
+            '200': {
+                description: 'Course model instance',
+                content: {'application/json': {schema: getModelSchemaRef(Requirement)}},
+            },
+        },
+    })
+    async create(
+        @param.path.number('id') id: typeof Course.prototype.id,
+        @requestBody({
+            content: {
+                'application/json': {
+                    schema: getModelSchemaRef(Requirement, {
+                        title: 'NewRequirementInCourse',
+                        exclude: ['id'],
+                        optional: ['courseId']
+                    }),
+                },
+            },
+        }) requirement: Omit<Requirement, 'id'>,
+    ): Promise<Requirement> {
+        return this.courseRepository.requirements(id).create(requirement);
+    }
+
+    @patch('/courses/{id}/requirements', {
+        responses: {
+            '200': {
+                description: 'Course.Requirement PATCH success count',
+                content: {'application/json': {schema: CountSchema}},
+            },
+        },
+    })
+    async patch(
+        @param.path.number('id') id: number,
+        @requestBody({
+            content: {
+                'application/json': {
+                    schema: getModelSchemaRef(Requirement, {partial: true}),
+                },
+            },
+        })
+            requirement: Partial<Requirement>,
+        @param.query.object('where', getWhereSchemaFor(Requirement)) where?: Where<Requirement>,
+    ): Promise<Count> {
+        return this.courseRepository.requirements(id).patch(requirement, where);
+    }
+
+    @del('/courses/{id}/requirements', {
+        responses: {
+            '200': {
+                description: 'Course.Requirement DELETE success count',
+                content: {'application/json': {schema: CountSchema}},
+            },
+        },
+    })
+    async delete(
+        @param.path.number('id') id: number,
+        @param.query.object('where', getWhereSchemaFor(Requirement)) where?: Where<Requirement>,
+    ): Promise<Count> {
+        return this.courseRepository.requirements(id).delete(where);
+    }
 }

backend/src/controllers/course-subject.controller.ts

@@ -1,38 +1,39 @@
 import {
-  repository,
+    repository,
 } from '@loopback/repository';
 import {
-  param,
-  get,
-  getModelSchemaRef,
+    param,
+    get,
+    getModelSchemaRef,
 } from '@loopback/rest';
 import {
-  Course,
-  Subject,
+    Course,
+    Subject,
 } from '../models';
-import {CourseRepository} from '../repositories';
+import { CourseRepository } from '../repositories';
 
 export class CourseSubjectController {
-  constructor(
-    @repository(CourseRepository)
-    public courseRepository: CourseRepository,
-  ) { }
+    constructor(
+        @repository(CourseRepository)
+        public courseRepository: CourseRepository,
+    ) {
+    }
 
-  @get('/courses/{id}/subject', {
-    responses: {
-      '200': {
-        description: 'Subject belonging to Course',
-        content: {
-          'application/json': {
-            schema: {type: 'array', items: getModelSchemaRef(Subject)},
-          },
+    @get('/courses/{id}/subject', {
+        responses: {
+            '200': {
+                description: 'Subject belonging to Course',
+                content: {
+                    'application/json': {
+                        schema: {type: 'array', items: getModelSchemaRef(Subject)},
+                    },
+                },
+            },
         },
-      },
-    },
-  })
-  async getSubject(
-    @param.path.number('id') id: typeof Course.prototype.id,
-  ): Promise<Subject> {
-    return this.courseRepository.subject(id);
-  }
+    })
+    async getSubject(
+        @param.path.number('id') id: typeof Course.prototype.id,
+    ): Promise<Subject> {
+        return this.courseRepository.subject(id);
+    }
 }

backend/src/controllers/course-user.controller.ts

@@ -1,109 +1,110 @@
 import {
-  Count,
-  CountSchema,
-  Filter,
-  repository,
-  Where,
+    Count,
+    CountSchema,
+    Filter,
+    repository,
+    Where,
 } from '@loopback/repository';
-  import {
-  del,
-  get,
-  getModelSchemaRef,
-  getWhereSchemaFor,
-  param,
-  patch,
-  post,
-  requestBody,
+import {
+    del,
+    get,
+    getModelSchemaRef,
+    getWhereSchemaFor,
+    param,
+    patch,
+    post,
+    requestBody,
 } from '@loopback/rest';
 import {
-Course,
-User,
+    Course,
+    User,
 } from '../models';
-import {CourseRepository} from '../repositories';
+import { CourseRepository } from '../repositories';
 
 export class CourseUserController {
-  constructor(
-    @repository(CourseRepository) protected courseRepository: CourseRepository,
-  ) { }
+    constructor(
+        @repository(CourseRepository) protected courseRepository: CourseRepository,
+    ) {
+    }
 
-  @get('/courses/{id}/users', {
-    responses: {
-      '200': {
-        description: 'Array of Course has many User through CourseUser',
-        content: {
-          'application/json': {
-            schema: {type: 'array', items: getModelSchemaRef(User)},
-          },
+    @get('/courses/{id}/users', {
+        responses: {
+            '200': {
+                description: 'Array of Course has many User through CourseUser',
+                content: {
+                    'application/json': {
+                        schema: {type: 'array', items: getModelSchemaRef(User)},
+                    },
+                },
+            },
         },
-      },
-    },
-  })
-  async find(
-    @param.path.number('id') id: number,
-    @param.query.object('filter') filter?: Filter<User>,
-  ): Promise<User[]> {
-    return this.courseRepository.users(id).find(filter);
-  }
-
-  @post('/courses/{id}/users', {
-    responses: {
-      '200': {
-        description: 'create a User model instance',
-        content: {'application/json': {schema: getModelSchemaRef(User)}},
-      },
-    },
-  })
-  async create(
-    @param.path.number('id') id: typeof Course.prototype.id,
-    @requestBody({
-      content: {
-        'application/json': {
-          schema: getModelSchemaRef(User, {
-            title: 'NewUserInCourse',
-            exclude: ['id'],
-          }),
-        },
-      },
-    }) user: Omit<User, 'id'>,
-  ): Promise<User> {
-    return this.courseRepository.users(id).create(user);
-  }
-
-  @patch('/courses/{id}/users', {
-    responses: {
-      '200': {
-        description: 'Course.User PATCH success count',
-        content: {'application/json': {schema: CountSchema}},
-      },
-    },
-  })
-  async patch(
-    @param.path.number('id') id: number,
-    @requestBody({
-      content: {
-        'application/json': {
-          schema: getModelSchemaRef(User, {partial: true}),
-        },
-      },
     })
-    user: Partial<User>,
-    @param.query.object('where', getWhereSchemaFor(User)) where?: Where<User>,
-  ): Promise<Count> {
-    return this.courseRepository.users(id).patch(user, where);
-  }
+    async find(
+        @param.path.number('id') id: number,
+        @param.query.object('filter') filter?: Filter<User>,
+    ): Promise<User[]> {
+        return this.courseRepository.users(id).find(filter);
+    }
 
-  @del('/courses/{id}/users', {
-    responses: {
-      '200': {
-        description: 'Course.User DELETE success count',
-        content: {'application/json': {schema: CountSchema}},
-      },
-    },
-  })
-  async delete(
-    @param.path.number('id') id: number,
-    @param.query.object('where', getWhereSchemaFor(User)) where?: Where<User>,
-  ): Promise<Count> {
-    return this.courseRepository.users(id).delete(where);
-  }
+    @post('/courses/{id}/users', {
+        responses: {
+            '200': {
+                description: 'create a User model instance',
+                content: {'application/json': {schema: getModelSchemaRef(User)}},
+            },
+        },
+    })
+    async create(
+        @param.path.number('id') id: typeof Course.prototype.id,
+        @requestBody({
+            content: {
+                'application/json': {
+                    schema: getModelSchemaRef(User, {
+                        title: 'NewUserInCourse',
+                        exclude: ['id'],
+                    }),
+                },
+            },
+        }) user: Omit<User, 'id'>,
+    ): Promise<User> {
+        return this.courseRepository.users(id).create(user);
+    }
+
+    @patch('/courses/{id}/users', {
+        responses: {
+            '200': {
+                description: 'Course.User PATCH success count',
+                content: {'application/json': {schema: CountSchema}},
+            },
+        },
+    })
+    async patch(
+        @param.path.number('id') id: number,
+        @requestBody({
+            content: {
+                'application/json': {
+                    schema: getModelSchemaRef(User, {partial: true}),
+                },
+            },
+        })
+            user: Partial<User>,
+        @param.query.object('where', getWhereSchemaFor(User)) where?: Where<User>,
+    ): Promise<Count> {
+        return this.courseRepository.users(id).patch(user, where);
+    }
+
+    @del('/courses/{id}/users', {
+        responses: {
+            '200': {
+                description: 'Course.User DELETE success count',
+                content: {'application/json': {schema: CountSchema}},
+            },
+        },
+    })
+    async delete(
+        @param.path.number('id') id: number,
+        @param.query.object('where', getWhereSchemaFor(User)) where?: Where<User>,
+    ): Promise<Count> {
+        return this.courseRepository.users(id).delete(where);
+    }
 }

backend/src/controllers/subject-course.controller.ts

@@ -1,110 +1,111 @@
 import {
-  Count,
-  CountSchema,
-  Filter,
-  repository,
-  Where,
+    Count,
+    CountSchema,
+    Filter,
+    repository,
+    Where,
 } from '@loopback/repository';
 import {
-  del,
-  get,
-  getModelSchemaRef,
-  getWhereSchemaFor,
-  param,
-  patch,
-  post,
-  requestBody,
+    del,
+    get,
+    getModelSchemaRef,
+    getWhereSchemaFor,
+    param,
+    patch,
+    post,
+    requestBody,
 } from '@loopback/rest';
 import {
-  Subject,
-  Course,
+    Subject,
+    Course,
 } from '../models';
-import {SubjectRepository} from '../repositories';
+import { SubjectRepository } from '../repositories';
 
 export class SubjectCourseController {
-  constructor(
-    @repository(SubjectRepository) protected subjectRepository: SubjectRepository,
-  ) { }
+    constructor(
+        @repository(SubjectRepository) protected subjectRepository: SubjectRepository,
+    ) {
+    }
 
-  @get('/subjects/{id}/courses', {
-    responses: {
-      '200': {
-        description: 'Array of Subject has many Course',
-        content: {
-          'application/json': {
-            schema: {type: 'array', items: getModelSchemaRef(Course)},
-          },
+    @get('/subjects/{id}/courses', {
+        responses: {
+            '200': {
+                description: 'Array of Subject has many Course',
+                content: {
+                    'application/json': {
+                        schema: {type: 'array', items: getModelSchemaRef(Course)},
+                    },
+                },
+            },
         },
-      },
-    },
-  })
-  async find(
-    @param.path.number('id') id: number,
-    @param.query.object('filter') filter?: Filter<Course>,
-  ): Promise<Course[]> {
-    return this.subjectRepository.courses(id).find(filter);
-  }
-
-  @post('/subjects/{id}/courses', {
-    responses: {
-      '200': {
-        description: 'Subject model instance',
-        content: {'application/json': {schema: getModelSchemaRef(Course)}},
-      },
-    },
-  })
-  async create(
-    @param.path.number('id') id: typeof Subject.prototype.id,
-    @requestBody({
-      content: {
-        'application/json': {
-          schema: getModelSchemaRef(Course, {
-            title: 'NewCourseInSubject',
-            exclude: ['id'],
-            optional: ['subjectId']
-          }),
-        },
-      },
-    }) course: Omit<Course, 'id'>,
-  ): Promise<Course> {
-    return this.subjectRepository.courses(id).create(course);
-  }
-
-  @patch('/subjects/{id}/courses', {
-    responses: {
-      '200': {
-        description: 'Subject.Course PATCH success count',
-        content: {'application/json': {schema: CountSchema}},
-      },
-    },
-  })
-  async patch(
-    @param.path.number('id') id: number,
-    @requestBody({
-      content: {
-        'application/json': {
-          schema: getModelSchemaRef(Course, {partial: true}),
-        },
-      },
     })
-    course: Partial<Course>,
-    @param.query.object('where', getWhereSchemaFor(Course)) where?: Where<Course>,
-  ): Promise<Count> {
-    return this.subjectRepository.courses(id).patch(course, where);
-  }
+    async find(
+        @param.path.number('id') id: number,
+        @param.query.object('filter') filter?: Filter<Course>,
+    ): Promise<Course[]> {
+        return this.subjectRepository.courses(id).find(filter);
+    }
 
-  @del('/subjects/{id}/courses', {
-    responses: {
-      '200': {
-        description: 'Subject.Course DELETE success count',
-        content: {'application/json': {schema: CountSchema}},
-      },
-    },
-  })
-  async delete(
-    @param.path.number('id') id: number,
-    @param.query.object('where', getWhereSchemaFor(Course)) where?: Where<Course>,
-  ): Promise<Count> {
-    return this.subjectRepository.courses(id).delete(where);
-  }
+    @post('/subjects/{id}/courses', {
+        responses: {
+            '200': {
+                description: 'Subject model instance',
+                content: {'application/json': {schema: getModelSchemaRef(Course)}},
+            },
+        },
+    })
+    async create(
+        @param.path.number('id') id: typeof Subject.prototype.id,
+        @requestBody({
+            content: {
+                'application/json': {
+                    schema: getModelSchemaRef(Course, {
+                        title: 'NewCourseInSubject',
+                        exclude: ['id'],
+                        optional: ['subjectId']
+                    }),
+                },
+            },
+        }) course: Omit<Course, 'id'>,
+    ): Promise<Course> {
+        return this.subjectRepository.courses(id).create(course);
+    }
+
+    @patch('/subjects/{id}/courses', {
+        responses: {
+            '200': {
+                description: 'Subject.Course PATCH success count',
+                content: {'application/json': {schema: CountSchema}},
+            },
+        },
+    })
+    async patch(
+        @param.path.number('id') id: number,
+        @requestBody({
+            content: {
+                'application/json': {
+                    schema: getModelSchemaRef(Course, {partial: true}),
+                },
+            },
+        })
+            course: Partial<Course>,
+        @param.query.object('where', getWhereSchemaFor(Course)) where?: Where<Course>,
+    ): Promise<Count> {
+        return this.subjectRepository.courses(id).patch(course, where);
+    }
+
+    @del('/subjects/{id}/courses', {
+        responses: {
+            '200': {
+                description: 'Subject.Course DELETE success count',
+                content: {'application/json': {schema: CountSchema}},
+            },
+        },
+    })
+    async delete(
+        @param.path.number('id') id: number,
+        @param.query.object('where', getWhereSchemaFor(Course)) where?: Where<Course>,
+    ): Promise<Count> {
+        return this.subjectRepository.courses(id).delete(where);
+    }
 }

backend/src/controllers/user-course.controller.ts

@@ -1,109 +1,110 @@
 import {
-  Count,
-  CountSchema,
-  Filter,
-  repository,
-  Where,
+    Count,
+    CountSchema,
+    Filter,
+    repository,
+    Where,
 } from '@loopback/repository';
-  import {
-  del,
-  get,
-  getModelSchemaRef,
-  getWhereSchemaFor,
-  param,
-  patch,
-  post,
-  requestBody,
+import {
+    del,
+    get,
+    getModelSchemaRef,
+    getWhereSchemaFor,
+    param,
+    patch,
+    post,
+    requestBody,
 } from '@loopback/rest';
 import {
-User,
-Course,
+    User,
+    Course,
 } from '../models';
-import {UserRepository} from '../repositories';
+import { UserRepository } from '../repositories';
 
 export class UserCourseController {
-  constructor(
-    @repository(UserRepository) protected userRepository: UserRepository,
-  ) { }
+    constructor(
+        @repository(UserRepository) protected userRepository: UserRepository,
+    ) {
+    }
 
-  @get('/users/{id}/courses', {
-    responses: {
-      '200': {
-        description: 'Array of User has many Course through CourseUser',
-        content: {
-          'application/json': {
-            schema: {type: 'array', items: getModelSchemaRef(Course)},
-          },
+    @get('/users/{id}/courses', {
+        responses: {
+            '200': {
+                description: 'Array of User has many Course through CourseUser',
+                content: {
+                    'application/json': {
+                        schema: {type: 'array', items: getModelSchemaRef(Course)},
+                    },
+                },
+            },
         },
-      },
-    },
-  })
-  async find(
-    @param.path.number('id') id: number,
-    @param.query.object('filter') filter?: Filter<Course>,
-  ): Promise<Course[]> {
-    return this.userRepository.courses(id).find(filter);
-  }
-
-  @post('/users/{id}/courses', {
-    responses: {
-      '200': {
-        description: 'create a Course model instance',
-        content: {'application/json': {schema: getModelSchemaRef(Course)}},
-      },
-    },
-  })
-  async create(
-    @param.path.number('id') id: typeof User.prototype.id,
-    @requestBody({
-      content: {
-        'application/json': {
-          schema: getModelSchemaRef(Course, {
-            title: 'NewCourseInUser',
-            exclude: ['id'],
-          }),
-        },
-      },
-    }) course: Omit<Course, 'id'>,
-  ): Promise<Course> {
-    return this.userRepository.courses(id).create(course);
-  }
-
-  @patch('/users/{id}/courses', {
-    responses: {
-      '200': {
-        description: 'User.Course PATCH success count',
-        content: {'application/json': {schema: CountSchema}},
-      },
-    },
-  })
-  async patch(
-    @param.path.number('id') id: number,
-    @requestBody({
-      content: {
-        'application/json': {
-          schema: getModelSchemaRef(Course, {partial: true}),
-        },
-      },
     })
-    course: Partial<Course>,
-    @param.query.object('where', getWhereSchemaFor(Course)) where?: Where<Course>,
-  ): Promise<Count> {
-    return this.userRepository.courses(id).patch(course, where);
-  }
+    async find(
+        @param.path.number('id') id: number,
+        @param.query.object('filter') filter?: Filter<Course>,
+    ): Promise<Course[]> {
+        return this.userRepository.courses(id).find(filter);
+    }
 
-  @del('/users/{id}/courses', {
-    responses: {
-      '200': {
-        description: 'User.Course DELETE success count',
-        content: {'application/json': {schema: CountSchema}},
-      },
-    },
-  })
-  async delete(
-    @param.path.number('id') id: number,
-    @param.query.object('where', getWhereSchemaFor(Course)) where?: Where<Course>,
-  ): Promise<Count> {
-    return this.userRepository.courses(id).delete(where);
-  }
+    @post('/users/{id}/courses', {
+        responses: {
+            '200': {
+                description: 'create a Course model instance',
+                content: {'application/json': {schema: getModelSchemaRef(Course)}},
+            },
+        },
+    })
+    async create(
+        @param.path.number('id') id: typeof User.prototype.id,
+        @requestBody({
+            content: {
+                'application/json': {
+                    schema: getModelSchemaRef(Course, {
+                        title: 'NewCourseInUser',
+                        exclude: ['id'],
+                    }),
+                },
+            },
+        }) course: Omit<Course, 'id'>,
+    ): Promise<Course> {
+        return this.userRepository.courses(id).create(course);
+    }
+
+    @patch('/users/{id}/courses', {
+        responses: {
+            '200': {
+                description: 'User.Course PATCH success count',
+                content: {'application/json': {schema: CountSchema}},
+            },
+        },
+    })
+    async patch(
+        @param.path.number('id') id: number,
+        @requestBody({
+            content: {
+                'application/json': {
+                    schema: getModelSchemaRef(Course, {partial: true}),
+                },
+            },
+        })
+            course: Partial<Course>,
+        @param.query.object('where', getWhereSchemaFor(Course)) where?: Where<Course>,
+    ): Promise<Count> {
+        return this.userRepository.courses(id).patch(course, where);
+    }
+
+    @del('/users/{id}/courses', {
+        responses: {
+            '200': {
+                description: 'User.Course DELETE success count',
+                content: {'application/json': {schema: CountSchema}},
+            },
+        },
+    })
+    async delete(
+        @param.path.number('id') id: number,
+        @param.query.object('where', getWhereSchemaFor(Course)) where?: Where<Course>,
+    ): Promise<Count> {
+        return this.userRepository.courses(id).delete(where);
+    }
 }

backend/src/controllers/user.controller.ts

@@ -1,16 +1,16 @@
-import {Count, CountSchema, Filter, FilterExcludingWhere, repository, Where,} from '@loopback/repository';
+import { Count, CountSchema, Filter, FilterExcludingWhere, repository, Where, } from '@loopback/repository';
 import { del, get, getModelSchemaRef, HttpErrors, param, patch, post, Request, requestBody, response, RestBindings, } from '@loopback/rest';
-import {User} from '../models';
-import {UserRepository} from '../repositories';
+import { User } from '../models';
+import { UserRepository } from '../repositories';
 import {
     TokenServiceBindings,
     UserServiceBindings
 } from '@loopback/authentication-jwt';
-import {inject} from '@loopback/core';
-import {authenticate, TokenService} from '@loopback/authentication';
-import {SecurityBindings, UserProfile} from '@loopback/security';
-import {genSalt, hash} from 'bcryptjs';
-import {SzakdolgozatUserService} from '../services';
+import { inject } from '@loopback/core';
+import { authenticate, TokenService } from '@loopback/authentication';
+import { SecurityBindings, UserProfile } from '@loopback/security';
+import { genSalt, hash } from 'bcryptjs';
+import { SzakdolgozatUserService } from '../services';
 
 export class UserController {
     constructor(
@@ -197,10 +197,11 @@ export class UserController {
         })
             user: User,
     ): Promise<void> {
-        if(id === +this.user.id) {
+        if (id === +this.user.id) {
             const loggedInUser = await this.userService.findUserById(this.user.id);
-            if(user.isAdmin !== undefined && loggedInUser.isAdmin !== user.isAdmin)
+            if (user.isAdmin !== undefined && loggedInUser.isAdmin !== user.isAdmin) {
                 throw new HttpErrors.BadRequest('Cannot change admin status of self');
+            }
         }
         await this.userRepository.updateById(id, user);
     }

backend/src/models/course-user.model.ts

@@ -1,40 +1,40 @@
-import {Entity, model, property} from '@loopback/repository';
+import { Entity, model, property } from '@loopback/repository';
 
 @model()
 export class CourseUser extends Entity {
-  @property({
-    type: 'number',
-    id: true,
-    generated: true,
-  })
-  id?: number;
+    @property({
+        type: 'number',
+        id: true,
+        generated: true,
+    })
+    id?: number;
 
-  @property({
-    type: 'number',
-    required: true,
-  })
-  courseId: number;
+    @property({
+        type: 'number',
+        required: true,
+    })
+    courseId: number;
 
-  @property({
-    type: 'number',
-    required: true,
-  })
-  userId: number;
+    @property({
+        type: 'number',
+        required: true,
+    })
+    userId: number;
 
-  @property({
-    type: 'string',
-    required: true,
-  })
-  role: string;
+    @property({
+        type: 'string',
+        required: true,
+    })
+    role: string;
 
 
-  constructor(data?: Partial<CourseUser>) {
-    super(data);
-  }
+    constructor(data?: Partial<CourseUser>) {
+        super(data);
+    }
 }
 
 export interface CourseUserRelations {
-  // describe navigational properties here
+    // describe navigational properties here
 }
 
 export type CourseUserWithRelations = CourseUser & CourseUserRelations;

backend/src/models/course.model.ts

@@ -1,40 +1,40 @@
-import {Entity, model, property, belongsTo, hasMany} from '@loopback/repository';
-import {Subject} from './subject.model';
-import {User} from './user.model';
-import {CourseUser} from './course-user.model';
-import {Requirement} from './requirement.model';
+import { Entity, model, property, belongsTo, hasMany } from '@loopback/repository';
+import { Subject } from './subject.model';
+import { User } from './user.model';
+import { CourseUser } from './course-user.model';
+import { Requirement } from './requirement.model';
 
 @model()
 export class Course extends Entity {
-  @property({
-    type: 'number',
-    id: true,
-    generated: true,
-  })
-  id?: number;
+    @property({
+        type: 'number',
+        id: true,
+        generated: true,
+    })
+    id?: number;
 
-  @property({
-    type: 'string',
-    required: true,
-  })
-  semester: string;
+    @property({
+        type: 'string',
+        required: true,
+    })
+    semester: string;
 
-  @belongsTo(() => Subject)
-  subjectId: number;
+    @belongsTo(() => Subject)
+    subjectId: number;
 
-  @hasMany(() => User, {through: {model: () => CourseUser}})
-  users: User[];
+    @hasMany(() => User, {through: {model: () => CourseUser}})
+    users: User[];
 
-  @hasMany(() => Requirement)
-  requirements: Requirement[];
+    @hasMany(() => Requirement)
+    requirements: Requirement[];
 
-  constructor(data?: Partial<Course>) {
-    super(data);
-  }
+    constructor(data?: Partial<Course>) {
+        super(data);
+    }
 }
 
 export interface CourseRelations {
-  // describe navigational properties here
+    // describe navigational properties here
 }
 
 export type CourseWithRelations = Course & CourseRelations;

backend/src/models/requirement.model.ts

@@ -1,44 +1,44 @@
-import {Entity, model, property} from '@loopback/repository';
+import { Entity, model, property } from '@loopback/repository';
 
 @model()
 export class Requirement extends Entity {
-  @property({
-    type: 'number',
-    id: true,
-    generated: true,
-  })
-  id?: number;
+    @property({
+        type: 'number',
+        id: true,
+        generated: true,
+    })
+    id?: number;
 
-  @property({
-    type: 'string',
-    required: true,
-  })
-  name: string;
+    @property({
+        type: 'string',
+        required: true,
+    })
+    name: string;
 
-  @property({
-    type: 'number',
-    required: true,
-  })
-  maxPoints: number;
+    @property({
+        type: 'number',
+        required: true,
+    })
+    maxPoints: number;
 
-  @property({
-    type: 'string',
-    required: true,
-  })
-  type: string;
+    @property({
+        type: 'string',
+        required: true,
+    })
+    type: string;
 
-  @property({
-    type: 'number',
-  })
-  courseId?: number;
+    @property({
+        type: 'number',
+    })
+    courseId?: number;
 
-  constructor(data?: Partial<Requirement>) {
-    super(data);
-  }
+    constructor(data?: Partial<Requirement>) {
+        super(data);
+    }
 }
 
 export interface RequirementRelations {
-  // describe navigational properties here
+    // describe navigational properties here
 }
 
 export type RequirementWithRelations = Requirement & RequirementRelations;

backend/src/models/subject.model.ts

@@ -1,36 +1,36 @@
-import {Entity, model, property, hasMany} from '@loopback/repository';
-import {Course} from './course.model';
+import { Entity, model, property, hasMany } from '@loopback/repository';
+import { Course } from './course.model';
 
 @model()
 export class Subject extends Entity {
-  @property({
-    type: 'number',
-    id: true,
-    generated: true,
-  })
-  id?: number;
+    @property({
+        type: 'number',
+        id: true,
+        generated: true,
+    })
+    id?: number;
 
-  @property({
-    type: 'string',
-    required: true,
-  })
-  name: string;
+    @property({
+        type: 'string',
+        required: true,
+    })
+    name: string;
 
-  @property({
-    type: 'string',
-  })
-  description?: string;
+    @property({
+        type: 'string',
+    })
+    description?: string;
 
-  @hasMany(() => Course)
-  courses: Course[];
+    @hasMany(() => Course)
+    courses: Course[];
 
-  constructor(data?: Partial<Subject>) {
-    super(data);
-  }
+    constructor(data?: Partial<Subject>) {
+        super(data);
+    }
 }
 
 export interface SubjectRelations {
-  // describe navigational properties here
+    // describe navigational properties here
 }
 
 export type SubjectWithRelations = Subject & SubjectRelations;

backend/src/models/user.model.ts

@@ -1,61 +1,61 @@
-import {Entity, model, property, hasMany} from '@loopback/repository';
-import {Course} from './course.model';
-import {CourseUser} from './course-user.model';
+import { Entity, model, property, hasMany } from '@loopback/repository';
+import { Course } from './course.model';
+import { CourseUser } from './course-user.model';
 
 @model()
 export class User extends Entity {
-  @property({
-    type: 'number',
-    id: true,
-    generated: true,
-  })
-  id?: number;
+    @property({
+        type: 'number',
+        id: true,
+        generated: true,
+    })
+    id?: number;
 
-  @property({
-    type: 'string',
-    required: true,
-    jsonSchema: {
-      pattern: /[A-Za-z0-9.+_-]+@[A-Za-z.-_]*(u-szeged.hu)|(szte.hu)/.source
+    @property({
+        type: 'string',
+        required: true,
+        jsonSchema: {
+            pattern: /[A-Za-z0-9.+_-]+@[A-Za-z.-_]*(u-szeged.hu)|(szte.hu)/.source
+        }
+    })
+    email: string;
+
+    @property({
+        type: 'string',
+        required: true,
+        jsonSchema: {
+            pattern: /([A-Za-z-.]+ )+[A-Za-z-.]+/.source
+        }
+    })
+    name: string;
+
+    @property({
+        type: 'string',
+        required: true,
+        jsonSchema: {
+            minLength: 8,
+            maxLength: 255
+        },
+        hidden: true
+    })
+    password: string;
+
+    @property({
+        type: 'boolean',
+        required: true,
+    })
+    isAdmin: boolean;
+
+    @hasMany(() => Course, {through: {model: () => CourseUser}})
+    courses: Course[];
+
+    constructor(data?: Partial<User>) {
+        super(data);
     }
-  })
-  email: string;
-
-  @property({
-    type: 'string',
-    required: true,
-    jsonSchema: {
-      pattern: /([A-Za-z-.]+ )+[A-Za-z-.]+/.source
-    }
-  })
-  name: string;
-
-  @property({
-    type: 'string',
-    required: true,
-    jsonSchema: {
-      minLength: 8,
-      maxLength: 255
-    },
-    hidden: true
-  })
-  password: string;
-
-  @property({
-    type: 'boolean',
-    required: true,
-  })
-  isAdmin: boolean;
-
-  @hasMany(() => Course, {through: {model: () => CourseUser}})
-  courses: Course[];
-
-  constructor(data?: Partial<User>) {
-    super(data);
-  }
 }
 
 export interface UserRelations {
-  // describe navigational properties here
+    // describe navigational properties here
 }
 
 export type UserWithRelations = User & UserRelations;

backend/src/repositories/course-user.repository.ts

@@ -1,16 +1,14 @@
-import {inject} from '@loopback/core';
-import {DefaultCrudRepository} from '@loopback/repository';
-import {DatabaseDataSource} from '../datasources';
-import {CourseUser, CourseUserRelations} from '../models';
+import { inject } from '@loopback/core';
+import { DefaultCrudRepository } from '@loopback/repository';
+import { DatabaseDataSource } from '../datasources';
+import { CourseUser, CourseUserRelations } from '../models';
 
-export class CourseUserRepository extends DefaultCrudRepository<
-  CourseUser,
-  typeof CourseUser.prototype.id,
-  CourseUserRelations
-> {
-  constructor(
-    @inject('datasources.database') dataSource: DatabaseDataSource,
-  ) {
-    super(CourseUser, dataSource);
-  }
+export class CourseUserRepository extends DefaultCrudRepository<CourseUser,
+    typeof CourseUser.prototype.id,
+    CourseUserRelations> {
+    constructor(
+        @inject('datasources.database') dataSource: DatabaseDataSource,
+    ) {
+        super(CourseUser, dataSource);
+    }
 }

backend/src/repositories/course.repository.ts

@@ -1,36 +1,39 @@
-import {inject, Getter} from '@loopback/core';
-import {DefaultCrudRepository, repository, BelongsToAccessor, HasManyThroughRepositoryFactory, HasManyRepositoryFactory} from '@loopback/repository';
-import {DatabaseDataSource} from '../datasources';
-import {Course, CourseRelations, Subject, User, CourseUser, Requirement} from '../models';
-import {SubjectRepository} from './subject.repository';
-import {CourseUserRepository} from './course-user.repository';
-import {UserRepository} from './user.repository';
-import {RequirementRepository} from './requirement.repository';
+import { inject, Getter } from '@loopback/core';
+import {
+    DefaultCrudRepository,
+    repository,
+    BelongsToAccessor,
+    HasManyThroughRepositoryFactory,
+    HasManyRepositoryFactory
+} from '@loopback/repository';
+import { DatabaseDataSource } from '../datasources';
+import { Course, CourseRelations, Subject, User, CourseUser, Requirement } from '../models';
+import { SubjectRepository } from './subject.repository';
+import { CourseUserRepository } from './course-user.repository';
+import { UserRepository } from './user.repository';
+import { RequirementRepository } from './requirement.repository';
 
-export class CourseRepository extends DefaultCrudRepository<
-  Course,
-  typeof Course.prototype.id,
-  CourseRelations
-> {
+export class CourseRepository extends DefaultCrudRepository<Course,
+    typeof Course.prototype.id,
+    CourseRelations> {
 
-  public readonly subject: BelongsToAccessor<Subject, typeof Course.prototype.id>;
+    public readonly subject: BelongsToAccessor<Subject, typeof Course.prototype.id>;
 
-  public readonly users: HasManyThroughRepositoryFactory<User, typeof User.prototype.id,
-          CourseUser,
-          typeof Course.prototype.id
-        >;
+    public readonly users: HasManyThroughRepositoryFactory<User, typeof User.prototype.id,
+        CourseUser,
+        typeof Course.prototype.id>;
 
-  public readonly requirements: HasManyRepositoryFactory<Requirement, typeof Course.prototype.id>;
+    public readonly requirements: HasManyRepositoryFactory<Requirement, typeof Course.prototype.id>;
 
-  constructor(
-    @inject('datasources.database') dataSource: DatabaseDataSource, @repository.getter('SubjectRepository') protected subjectRepositoryGetter: Getter<SubjectRepository>, @repository.getter('CourseUserRepository') protected courseUserRepositoryGetter: Getter<CourseUserRepository>, @repository.getter('UserRepository') protected userRepositoryGetter: Getter<UserRepository>, @repository.getter('RequirementRepository') protected requirementRepositoryGetter: Getter<RequirementRepository>,
-  ) {
-    super(Course, dataSource);
-    this.requirements = this.createHasManyRepositoryFactoryFor('requirements', requirementRepositoryGetter,);
-    this.registerInclusionResolver('requirements', this.requirements.inclusionResolver);
-    this.users = this.createHasManyThroughRepositoryFactoryFor('users', userRepositoryGetter, courseUserRepositoryGetter,);
-    this.registerInclusionResolver('users', this.users.inclusionResolver);
-    this.subject = this.createBelongsToAccessorFor('subject', subjectRepositoryGetter,);
-    this.registerInclusionResolver('subject', this.subject.inclusionResolver);
-  }
+    constructor(
+        @inject('datasources.database') dataSource: DatabaseDataSource, @repository.getter('SubjectRepository') protected subjectRepositoryGetter: Getter<SubjectRepository>, @repository.getter('CourseUserRepository') protected courseUserRepositoryGetter: Getter<CourseUserRepository>, @repository.getter('UserRepository') protected userRepositoryGetter: Getter<UserRepository>, @repository.getter('RequirementRepository') protected requirementRepositoryGetter: Getter<RequirementRepository>,
+    ) {
+        super(Course, dataSource);
+        this.requirements = this.createHasManyRepositoryFactoryFor('requirements', requirementRepositoryGetter,);
+        this.registerInclusionResolver('requirements', this.requirements.inclusionResolver);
+        this.users = this.createHasManyThroughRepositoryFactoryFor('users', userRepositoryGetter, courseUserRepositoryGetter,);
+        this.registerInclusionResolver('users', this.users.inclusionResolver);
+        this.subject = this.createBelongsToAccessorFor('subject', subjectRepositoryGetter,);
+        this.registerInclusionResolver('subject', this.subject.inclusionResolver);
+    }
 }

backend/src/repositories/requirement.repository.ts

@@ -1,16 +1,14 @@
-import {inject} from '@loopback/core';
-import {DefaultCrudRepository} from '@loopback/repository';
-import {DatabaseDataSource} from '../datasources';
-import {Requirement, RequirementRelations} from '../models';
+import { inject } from '@loopback/core';
+import { DefaultCrudRepository } from '@loopback/repository';
+import { DatabaseDataSource } from '../datasources';
+import { Requirement, RequirementRelations } from '../models';
 
-export class RequirementRepository extends DefaultCrudRepository<
-  Requirement,
-  typeof Requirement.prototype.id,
-  RequirementRelations
-> {
-  constructor(
-    @inject('datasources.database') dataSource: DatabaseDataSource,
-  ) {
-    super(Requirement, dataSource);
-  }
+export class RequirementRepository extends DefaultCrudRepository<Requirement,
+    typeof Requirement.prototype.id,
+    RequirementRelations> {
+    constructor(
+        @inject('datasources.database') dataSource: DatabaseDataSource,
+    ) {
+        super(Requirement, dataSource);
+    }
 }

backend/src/repositories/subject.repository.ts

@@ -1,23 +1,21 @@
-import {inject, Getter} from '@loopback/core';
-import {DefaultCrudRepository, repository, HasManyRepositoryFactory} from '@loopback/repository';
-import {DatabaseDataSource} from '../datasources';
-import {Subject, SubjectRelations, Course} from '../models';
-import {UserRepository} from './user.repository';
-import {CourseRepository} from './course.repository';
+import { inject, Getter } from '@loopback/core';
+import { DefaultCrudRepository, repository, HasManyRepositoryFactory } from '@loopback/repository';
+import { DatabaseDataSource } from '../datasources';
+import { Subject, SubjectRelations, Course } from '../models';
+import { UserRepository } from './user.repository';
+import { CourseRepository } from './course.repository';
 
-export class SubjectRepository extends DefaultCrudRepository<
-  Subject,
-  typeof Subject.prototype.id,
-  SubjectRelations
-> {
+export class SubjectRepository extends DefaultCrudRepository<Subject,
+    typeof Subject.prototype.id,
+    SubjectRelations> {
 
-  public readonly courses: HasManyRepositoryFactory<Course, typeof Subject.prototype.id>;
+    public readonly courses: HasManyRepositoryFactory<Course, typeof Subject.prototype.id>;
 
-  constructor(
-    @inject('datasources.database') dataSource: DatabaseDataSource, @repository.getter('UserRepository') protected userRepositoryGetter: Getter<UserRepository>, @repository.getter('CourseRepository') protected courseRepositoryGetter: Getter<CourseRepository>,
-  ) {
-    super(Subject, dataSource);
-    this.courses = this.createHasManyRepositoryFactoryFor('courses', courseRepositoryGetter,);
-    this.registerInclusionResolver('courses', this.courses.inclusionResolver);
-  }
+    constructor(
+        @inject('datasources.database') dataSource: DatabaseDataSource, @repository.getter('UserRepository') protected userRepositoryGetter: Getter<UserRepository>, @repository.getter('CourseRepository') protected courseRepositoryGetter: Getter<CourseRepository>,
+    ) {
+        super(Subject, dataSource);
+        this.courses = this.createHasManyRepositoryFactoryFor('courses', courseRepositoryGetter,);
+        this.registerInclusionResolver('courses', this.courses.inclusionResolver);
+    }
 }

backend/src/repositories/user.repository.ts

@@ -1,27 +1,24 @@
-import {inject, Getter} from '@loopback/core';
+import { inject, Getter } from '@loopback/core';
 import { repository, HasManyThroughRepositoryFactory, DefaultTransactionalRepository } from '@loopback/repository';
-import {DatabaseDataSource} from '../datasources';
-import {User, UserRelations, Course, CourseUser} from '../models';
-import {SubjectRepository} from './subject.repository';
-import {CourseUserRepository} from './course-user.repository';
-import {CourseRepository} from './course.repository';
+import { DatabaseDataSource } from '../datasources';
+import { User, UserRelations, Course, CourseUser } from '../models';
+import { SubjectRepository } from './subject.repository';
+import { CourseUserRepository } from './course-user.repository';
+import { CourseRepository } from './course.repository';
 
-export class UserRepository extends DefaultTransactionalRepository<
-  User,
-  typeof User.prototype.id,
-  UserRelations
-> {
+export class UserRepository extends DefaultTransactionalRepository<User,
+    typeof User.prototype.id,
+    UserRelations> {
 
-  public readonly courses: HasManyThroughRepositoryFactory<Course, typeof Course.prototype.id,
-          CourseUser,
-          typeof User.prototype.id
-        >;
+    public readonly courses: HasManyThroughRepositoryFactory<Course, typeof Course.prototype.id,
+        CourseUser,
+        typeof User.prototype.id>;
 
-  constructor(
-    @inject('datasources.database') dataSource: DatabaseDataSource, @repository.getter('SubjectRepository') protected subjectRepositoryGetter: Getter<SubjectRepository>, @repository.getter('CourseUserRepository') protected courseUserRepositoryGetter: Getter<CourseUserRepository>, @repository.getter('CourseRepository') protected courseRepositoryGetter: Getter<CourseRepository>,
-  ) {
-    super(User, dataSource);
-    this.courses = this.createHasManyThroughRepositoryFactoryFor('courses', courseRepositoryGetter, courseUserRepositoryGetter,);
-    this.registerInclusionResolver('courses', this.courses.inclusionResolver);
-  }
+    constructor(
+        @inject('datasources.database') dataSource: DatabaseDataSource, @repository.getter('SubjectRepository') protected subjectRepositoryGetter: Getter<SubjectRepository>, @repository.getter('CourseUserRepository') protected courseUserRepositoryGetter: Getter<CourseUserRepository>, @repository.getter('CourseRepository') protected courseRepositoryGetter: Getter<CourseRepository>,
+    ) {
+        super(User, dataSource);
+        this.courses = this.createHasManyThroughRepositoryFactoryFor('courses', courseRepositoryGetter, courseUserRepositoryGetter,);
+        this.registerInclusionResolver('courses', this.courses.inclusionResolver);
+    }
 }

backend/src/services/user.service.ts

@@ -3,67 +3,68 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
-import {UserService} from '@loopback/authentication';
-import {repository} from '@loopback/repository';
-import {HttpErrors} from '@loopback/rest';
-import {securityId, UserProfile} from '@loopback/security';
-import {compare} from 'bcryptjs';
-import {User, UserWithRelations} from '../models';
-import {UserRepository} from '../repositories';
+import { UserService } from '@loopback/authentication';
+import { repository } from '@loopback/repository';
+import { HttpErrors } from '@loopback/rest';
+import { securityId, UserProfile } from '@loopback/security';
+import { compare } from 'bcryptjs';
+import { User, UserWithRelations } from '../models';
+import { UserRepository } from '../repositories';
 
 /**
  * A pre-defined type for user credentials. It assumes a user logs in
  * using the email and password. You can modify it if your app has different credential fields
  */
 export type Credentials = {
-  email: string;
-  password: string;
+    email: string;
+    password: string;
 };
 
 export class SzakdolgozatUserService implements UserService<User, Credentials> {
-  constructor(
-      @repository(UserRepository) public userRepository: UserRepository,
-  ) { }
-
-  async verifyCredentials(credentials: Credentials): Promise<User> {
-    const invalidCredentialsError = 'Invalid email or password.';
-
-    const foundUser = await this.userRepository.findOne({
-      where: {email: credentials.email},
-    });
-    if (!foundUser) {
-      throw new HttpErrors.Unauthorized(invalidCredentialsError);
+    constructor(
+        @repository(UserRepository) public userRepository: UserRepository,
+    ) {
     }
 
-    const passwordMatched = await compare(
-        credentials.password,
-        foundUser.password,
-    );
+    async verifyCredentials(credentials: Credentials): Promise<User> {
+        const invalidCredentialsError = 'Invalid email or password.';
 
-    if (!passwordMatched) {
-      throw new HttpErrors.Unauthorized(invalidCredentialsError);
+        const foundUser = await this.userRepository.findOne({
+            where: {email: credentials.email},
+        });
+        if (!foundUser) {
+            throw new HttpErrors.Unauthorized(invalidCredentialsError);
+        }
+
+        const passwordMatched = await compare(
+            credentials.password,
+            foundUser.password,
+        );
+
+        if (!passwordMatched) {
+            throw new HttpErrors.Unauthorized(invalidCredentialsError);
+        }
+
+        return foundUser;
     }
 
-    return foundUser;
-  }
-
-  convertToUserProfile({email, id, name}: User): UserProfile {
-    return {
-      [securityId]: id!.toString(),
-      name,
-      id,
-      email,
-    };
-  }
-
-  //function to find user by id
-  async findUserById(id: number): Promise<User & UserWithRelations> {
-    const userNotfound = 'invalid user';
-    const foundUser = await this.userRepository.findById(id);
-
-    if (!foundUser) {
-      throw new HttpErrors.Unauthorized(userNotfound);
+    convertToUserProfile({email, id, name}: User): UserProfile {
+        return {
+            [securityId]: id!.toString(),
+            name,
+            id,
+            email,
+        };
+    }
+
+    //function to find user by id
+    async findUserById(id: number): Promise<User & UserWithRelations> {
+        const userNotfound = 'invalid user';
+        const foundUser = await this.userRepository.findById(id);
+
+        if (!foundUser) {
+            throw new HttpErrors.Unauthorized(userNotfound);
+        }
+        return foundUser;
     }
-    return foundUser;
-  }
 }

frontend/src/app/app.component.html

@@ -10,7 +10,7 @@
     </mat-nav-list>
   </mat-sidenav>
   <mat-sidenav-content>
-    <mat-toolbar color="primary">
+    <mat-toolbar color="primary" style="z-index: 1000">
       <button
         type="button"
         aria-label="Oldalsáv"