How uob-team-project/team00 works
Main Components
• Frontend Component:
• Located under the src/main/webapp folder.
• Built with Angular (note the Angular CLI configuration files, webpack configurations, and numerous Angular components in folders like /app/home, /app/account, /app/admin, etc.).
• Handles user interface, routing, and client-side validations.
• Backend Component:
• Located under src/main/java.
• Built with Spring Boot—includes REST controllers (in src/main/java/bham/team/web/rest), services, repositories, domain models, configuration classes, and security.
• Uses JWT for stateless authentication and has configuration for caching, database integration (using Liquibase for migrations), and a security layer.
• Database and Persistence:
• Configured for both in-memory H2 (for development) and PostgreSQL (for production).
• Liquibase changelogs are located in src/main/resources/config/liquibase.
• External Services and Infrastructure:
• Docker configurations (in src/main/docker) for multiple services such as PostgreSQL, Prometheus, Grafana, and others. These files outline the container orchestration for a production or test scenario.
• CI/CD pipelines for GitHub and GitLab are defined (.github/workflows/main.yml and .gitlab-ci.yml).
• The project uses Maven for backend build and npm (with wrapper scripts) for frontend development.
• Development Environment Tools:
• Dev container configuration and support files (in .devcontainer).
• Additional tools for code style, testing (Jest for Angular, JUnit for Java), linting (eslint, prettier, checkstyle), and version control hooks (husky).
Relationships and Interactions Between Components
• The backend’s controllers delegate requests to service layers, which in turn interact with repository layers and finally persist or access data in the database.
• External integrations such as Grafana and Prometheus (visible in the docker folder) monitor the application’s health and performance.
• Authentication is implemented via JWT; hence, the security configuration and filters should be represented as a middleware component between client requests and backend processing.
• Build and deployment pipelines (Maven, npm, Docker, CI/CD pipelines) tie into the development lifecycle, so include these as supporting infrastructure.
Architectural Patterns and Design Principles
• Layered (n-tier) Architecture: Clearly separated layers for presentation (Angular UI), business (Spring services), persistence (repositories + Liquibase configurations), and integration.
• Separation of Concerns: Different directories and configuration files demonstrate well-modularized components.
• Containerization and DevOps Focus: Presence of Docker (for local, production, and monitoring) and CI/CD configuration files shows a design mindful of modern deployment practices.
Relevant Technologies and Frameworks
• Backend: Java 21 (Spring Boot), Maven, Spring Security (with JWT), Liquibase, and JHipster’s code generation conventions.
• Frontend: Angular (with Angular CLI and Webpack), TypeScript, and testing with Jest.
• Containerization: Docker Compose configurations that include services like PostgreSQL, Prometheus, Grafana.
• CI/CD: GitHub Actions and GitLab CI.
• Additional tools: ESLint, Prettier, Husky, and various configuration files for IDE/editor settings.
Instructing the Principal Software Engineer
• Labeled components for “Angular Frontend”, “Spring Boot Backend”, “Database (PostgreSQL/H2)”, “Monitoring Services (Prometheus, Grafana)”, “CI/CD (GitHub/GitLab Pipelines)”, and “Containerization (Docker Configurations)”.
• Annotations on security, showing that JWT is used for authentication, and include middleware components (Spring Security Filters).
• Be detailed:
• Don’t shy away from breaking down the backend into its layers (Controllers, Services, Repositories) and showing the Angular routes along with key components like account management, admin features, and the GDPR policy.
• To include the Docker infrastructure and build tools as these are central to the application’s deployment and development workflow.
• Since you’re addressing a principal software engineer, it is beneficial to have both high-level components (the overall client-server separation) as well as detailed sub-components (layered backend architecture, Angular module structure, and CI/CD pipelines).