This post is part of a Series of post which I’m describing a clock-in/out system
if you want to read more you can read the following posts:
- Part 1. Clock-in/out System: Diagram.
- Part 2. Clock-in/out System: Basic backend — AuthModule.
- Part 3. Clock-in/out System: Basic backend — UsersModule.
- Part 4. Clock-in/out System: Basic backend- AppModule.
- Part 5. Clock-in/out System: Seed Database and migration data
- Part 6. Clock-in/out System: Basic frontend.
- Part 7. Clock-in/out System: Deploy backend (nestJS) using docker/docker-compose.
- Part 8. Clock-in/out System: Deploy frontend (Angular 2+) using environments.
- Part 9. Testing: Backend Testing — Unit Testing - Services
- Part 10. Testing: Backend Testing — Unit Testing - Controllers
- Part 11. Testing: Backend Testing — E2E Testing
- Part 12. Testing: Frontend Testing — Unit Testing
- Part 13. Testing: Frontend Testing — Integration Testing
In the first post (Part 1. Clock-in/out System: Diagram) we described the different components of our clock-in/out system. So, if you don’t
understand the architecture of the system you can read that post because I’ve
described each component of the system.
Originally published at www.carloscaballero.io on November 25, 2018.
In this post, I’m going to describe the basic backend using NestJS. The first
step is understand which is the directory structure. If you use the NestJS
starter project to start a project you could to do the following steps:
After that, we need create our own modules structure inside src directory as
you can see in Figure 1.
In this moment the server is running in port
3000 and the endpoint
http://localhost:3000/ using the verb
GET is working. If you navigate on
this address you get a message of
Hello World as shown in Figure 2.
The next step is define which are the modules need to our backend:
- DatabaseModule: This module is used to shared the database connection between different modules.
- AuthModule: This module is used to register in the database when an user clock-in and clock-out. The service AuthService will be the responsible for save in the database when an user check-in and check-out. This module there are not accesible since external. So, there are not a controller to communicate using API.
- UserModule: This module is used to manage the user information. The service UserService provide two important methods: **1. getUsersWithoutKey;
- addUser**. These method are used to know that user have not a valid ID Card and add an user to the system.
- AppModule: This module is the main module which will be communicate with the frontend. In this module the others modules will be imports, so the services of these modules can be used in this module. The main controller in this module have the following endpoints:
- POST: /in: This endpoint call the method authIn from the AuthService.
- POST: /out: This endpoint call the method authOut from the AuthService.
- GET: /users: This endpoint call method getUsersMustBeWorkingNow from the UsersService and combine the information together the timestamp of the server.
The module database is used to shared the DatabaseConnection. We’re using
TypeORM as ORM which is integrated perfectly in NestJS. So the definition of our
database.module is the following:
In the provider we’re defining our
DbConnectionToken using a factory. In our
case we're using
Postgres as database. So, the most interesting part is the
definition of entities which are automatically detect in
NestJS include a specify module to manage
TypeORM connection, I prefer
configure the provider using directly the method createConnection from typeorm
In this point, we must to install the following libraries in node:
npm i typeorm pg
So, the next step is install a database Postgres in your machine but I think
that the use of Docker is better option because you can get a clean environment
to develop which will be the same when you deploy.
So, the docker-compose in which you will be a container called
PostgreTestClock using the port 5531 is the following:
So, to start the database of the system only run the command
docker-compose. This module will be used by other modules to connect to the database.
The second module that we have implemented is AuthModule, this module have the
structure show in the Figure 3. You can note that there are several directories
as constants, DTOs and entities which are used to organised a module
independently as a service. The idea is build as module as a service because any
day you could build microservices. However, in this project all modules are
relation between them because is architecture is very complex to this project.
In the definition of auth.module you can see that imports DatabaseModule
and UsersModule. The DatabaseModule is used to connect to the database (show
previously) and the UsersModule is used to check information about the users in
the AuthModule. In this moment, the module UsersModule is still under
development (following post). The service AuthService is exported because the
future AppController will use this service.
The next step is know that information is saved in the database. That’s define
using the file user.entity.
The fields the class AuthEntity are the following:
- id_key: That’s the UID’s table. This field is generated automatically by TypeORM.
- reader: That’s the device which send the user’s key. In this project there are two readers — Input and Output.
- user: That’s the relation between Auth and User. In TypeORM you can use the decorator @ManyToOne to define that there are several entries in authentication for each user. The relation is doing using the field key of the user. In the User entity is required define the field key with the inverse decorator (@OneToMany). In the following post we will describe this module (at the moment is commented).
- timestamp: This is the moment in unix timestamp that the input or output was done. So, that’s very important because we need know the exact moment which the user clock-in/out in the system.
Finally, the provider file export two repositories to fast access to the
database. The pattern used is the Repository. So, you can inject those providers
using their token (AUTH_REPOSITORY_TOKEN and USER_REPOSITORY_TOKEN) in any
service or controller.
Now, I’m going to show the most easy part of my code but very important. The
constant file and the DTO. The constant file is very useful when you want to
coding clean code (is a good practice don’t use strings or numbers in your code)
and the DTOs define the information which is exchange between client-side and
The auth.constant file only have STATUS_CODE_RESPONSE to the Arduino system
which understand 0 as KO and 2 as OK and several moment formats.
The following DTOs are very simple because only show the interface of an input
(AuthDto) and an output (AuthResponseDto).
The AuthService should has two important methods:
- authIn: This method received a signal from the Arduino and save the information when a user clock-in in the system. The service response with a welcome message.
- authOut: This method received a signal from the Arduino and save the information when a user clock-out in the system. The service response with a bye message.
The code of this methods are the following:
In this class, I’ve inject two repositories (authRepository and userRepository)
which are used to communicate with database. The code is clean because I’ve used
simple async/await and private methods (saveTicketing, welcomeTeacher and
byeTeacher). So, the methods authIn and authOut are simple to
testing in the future. The response of the both methods is an
The private method saveTicketing is very simple too, the first step is get
the user which the key is associated (auth.key come from the Arduino). After,
you can save the information of authentication:
- key and reader from auth.
- user from the database (UserEntity).
- timestamp which is calculated from the library momentJS.
Finally the two methods which show the message to the user (that’s show in the
Arduino screen) are the following:
Finally, if you want to see the complete code of AuthService is the following:
In this post I’ve explain my AuthModule which is very simple because I’m using
clean code in my coding. This module is used to save the information about
In the following post of this series I’m going to explain the UsersModule and
The GitHub project is
The GitHub branch of this post is
*Originally published at www.carloscaballero.io on November 25, 2018.