Grade Manager

Technology Decisions

After completing various vocational training courses, we had access to a broad range of technologies. For the backend, we learned Spring Boot, and for the frontend, we gained experience with React Native.

Since we had recently worked intensively with both technologies in our courses, we decided to continue with this stack. React Native was particularly appealing because it allows us to develop the application once and export it for all platforms.

For the data layer, we chose MariaDB, a relational database that we had also used in our training courses.

Project Language Distribution

TypeScript 87.1%

Java 12.5%

JavaScript 0.4%

Use Cases

GitHub Projects Integration

To make the implementation process of our 3-tier application as timely and enjoyable as possible, we placed great emphasis on planning. We had excellent experiences with GitHub Projects in previous projects.

Issues in our GitHub repository are graphically displayed through GitHub Projects in a Kanban board, giving us as developers a direct overview of the application's development status.

Kanban Board Overview

Initially, we created the most necessary tasks as issues in the Ready column and clarified who would start with which task. The biggest advantage for us developers is that everyone can work independently and assign themselves a task they're interested in. Once a task is completed, it's moved to "In review" so the other team member can review the implementation, providing opportunities for mutual learning.

Frontend Architecture

We work with the React Native framework, which allows us to compile a cross-platform app. As developers, we only need to write the code once, and it works on all platforms.

Models

In our application, classes are stored in a folder named "model". We have 2 main classes: the Grade class and the User class, containing all attributes our application needs.

Services

Services handle processes that aren't directly related to the UI. We created 3 services:

Component Architecture

Backend Architecture

We work with the Spring Framework, which simplifies backend application creation with features like easy-to-configure REST endpoints and automatic DDL generation with Hibernate.

Entities

Each database table has a corresponding entity represented by a Java class with important annotations:

@Entity (name = "grades")
@Setter
@Getter
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class Grade {
    @Id
    private String id;
    private String name;
    private double grade;
    private String subject;
    private String school;
    
    @ManyToOne
    @JoinColumn(name = "user_id")
    private User user;
}

Controllers

REST endpoints are created using controllers, serving as the interface between the Spring Boot application and the internet:

@RestController
@RequiredArgsConstructor
@RequestMapping("/api/grades")
public class GradeController {
    private final GradeService gradeService;

    @GetMapping("/user/{id}")
    public List<Grade> getGradesByUserID(@PathVariable("id") String userId) {
        return gradeService.getGradesByUserID(userId);
    }

    @PostMapping("/persistence/addgrade")
    public Grade saveGrade(@RequestBody Grade grade) throws LoginException {
        return gradeService.saveGrade(grade);
    }

    @DeleteMapping("/delete/{id}")
    public void deleteGradeByID(@PathVariable("id") String gradeId) {
        gradeService.deleteGradeByID(gradeId);
    }

    @PutMapping("/update/{id}")
    public Grade updateGradeByID(
        @PathVariable("id") String gradeId, 
        @RequestBody Grade updatedGrade
    ) {
        return gradeService.updateGradeByID(gradeId, updatedGrade);
    }
}

Services

Services process data from endpoints, handling calculations, modifications, and creation. They typically consist of an interface and corresponding implementation:

public interface GradeService {
    List<Grade> getAllGrades();
    Grade getGradeByID(String id);
    Grade saveGrade(Grade grade);
    List<Grade> getGradesByUserID(String userId);
    void deleteGradeByID(String gradeId);
    Grade updateGradeByID(String gradeId, Grade newGrade);
}

@Service
public class GradeServiceImpl implements GradeService {
    @Autowired
    private GradeRepository gradeRepository;

    @Override
    public Grade saveGrade(Grade grade) {
        return gradeRepository.save(grade);
    }

    @Override
    public void deleteGradeByID(String gradeId) {
        gradeRepository.deleteById(gradeId);
    }
}

Repository

The repository is crucial for data management, providing easy database communication and serving as the interface between Java code and SQL queries:

@Repository
public interface GradeRepository extends JpaRepository<Grade, String> {
    List<Grade> findByUser_Id(String id);
}

The interface has minimal content because we inherit from JpaRepository, providing many predefined methods like findById() and getAll(). Spring handles the implementation internally, saving significant development time.

Testing Environment

Test Cases

We conducted comprehensive testing covering all major functionality areas: