feat: add help button #541

backend/src/main/java/ch/puzzle/pcts/configuration/AppConfiguration.java

@@ -0,0 +1,19 @@
+package ch.puzzle.pcts.configuration;
+
+import jakarta.validation.constraints.AssertTrue;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.validation.annotation.Validated;
+
+@Validated
+@ConfigurationProperties(prefix = "pcts.app")
+public record AppConfiguration(String helpurl) {
+    public String getHelpUrl() {
+        return helpurl;
+    }
+
+    @AssertTrue(message = "Help url is not a valid url")
+    public boolean isValid() {
+        return helpurl != null && !helpurl.isBlank() && !helpurl.contains(" ") && helpurl.startsWith("https://")
+               && helpurl.length() >= 12 && (helpurl.contains(".ch") || helpurl.contains(".com"));
+    }
+}

backend/src/main/java/ch/puzzle/pcts/controller/ConfigurationController.java

@@ -1,7 +1,10 @@
 package ch.puzzle.pcts.controller;
 
+import ch.puzzle.pcts.configuration.AppConfiguration;
 import ch.puzzle.pcts.configuration.AuthorizationConfiguration;
+import ch.puzzle.pcts.dto.appconfiguration.AppConfigurationDto;
 import ch.puzzle.pcts.dto.configuration.ConfigurationDto;
+import ch.puzzle.pcts.mapper.AppConfigurationMapper;
 import ch.puzzle.pcts.mapper.ConfigurationMapper;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import org.springframework.http.ResponseEntity;
@@ -13,16 +16,26 @@
 @RequestMapping("/api/v1/configuration")
 @Tag(name = "configuration", description = "Retrieve configuration properties for the application")
 public class ConfigurationController {
-    private final ConfigurationMapper mapper;
+    private final ConfigurationMapper configMapper;
     private final AuthorizationConfiguration authConfig;
+    private final AppConfigurationMapper appConfigMapper;
+    private final AppConfiguration appConfig;
 
-    public ConfigurationController(ConfigurationMapper mapper, AuthorizationConfiguration authConfig) {
-        this.mapper = mapper;
+    public ConfigurationController(ConfigurationMapper configMapper, AuthorizationConfiguration authConfig,
+                                   AppConfigurationMapper appConfigMapper, AppConfiguration appConfig) {
+        this.configMapper = configMapper;
         this.authConfig = authConfig;
+        this.appConfigMapper = appConfigMapper;
+        this.appConfig = appConfig;
     }
 
-    @GetMapping
+    @GetMapping("/authorization")
     public ResponseEntity<ConfigurationDto> getAuthorizationConfiguration() {
-        return ResponseEntity.ok(mapper.toDto(this.authConfig));
+        return ResponseEntity.ok(configMapper.toDto(this.authConfig));
+    }
+
+    @GetMapping("/app")
+    public ResponseEntity<AppConfigurationDto> getHelpUrl() {
+        return ResponseEntity.ok(appConfigMapper.toDto(this.appConfig.getHelpUrl()));
     }
 }

backend/src/main/java/ch/puzzle/pcts/dto/appconfiguration/AppConfigurationDto.java

@@ -0,0 +1,7 @@
+package ch.puzzle.pcts.dto.appconfiguration;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+
+public record AppConfigurationDto(@Schema(description = "Provides the url the help button should lead to") String url) {
+
+}

backend/src/main/java/ch/puzzle/pcts/mapper/AppConfigurationMapper.java

@@ -0,0 +1,11 @@
+package ch.puzzle.pcts.mapper;
+
+import ch.puzzle.pcts.dto.appconfiguration.AppConfigurationDto;
+import org.springframework.stereotype.Component;
+
+@Component
+public class AppConfigurationMapper {
+    public AppConfigurationDto toDto(String url) {
+        return new AppConfigurationDto(url);
+    }
+}

backend/src/main/java/ch/puzzle/pcts/security/SpringSecurityConfig.java

@@ -32,7 +32,7 @@ public SecurityFilterChain filterChain(HttpSecurity http) {
                         .permitAll()
                         .requestMatchers("/actuator/health/**")
                         .permitAll()
-                        .requestMatchers("/api/v1/configuration")
+                        .requestMatchers("/api/v1/configuration/**")
                         .permitAll()
                         .anyRequest()
                         .authenticated())

backend/src/main/resources/application-dev.properties

@@ -27,6 +27,8 @@ app.member-sync.password=
 app.member-sync.enabled=false
 app.member-sync.cron=0 * * * * ?
 
+pcts.app.helpurl=https://google.com
+
 # OAuth
 spring.security.oauth2.resourceserver.jwt.issuer-uri=http://localhost:8544/realms/pitc
 spring.security.oauth2.resourceserver.jwt.jwk-set-uri=http://localhost:8544/realms/pitc/protocol/openid-connect/certs

backend/src/main/resources/application-e2e-test.properties

@@ -21,6 +21,8 @@ app.member-sync.cron=0 0 3 * * ?
 app.member-sync.username=
 app.member-sync.password=
 
+pcts.app.helpurl=https://dummy-url.ch
+
 # Authentication & JWT
 pcts.security.authentication.display-name-claim=name
 pcts.security.authorization.admin-authorities=org_hr,org_gl

backend/src/test/java/ch/puzzle/pcts/configuration/AppConfigurationTest.java

@@ -0,0 +1,46 @@
+package ch.puzzle.pcts.configuration;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import jakarta.validation.Validation;
+import jakarta.validation.Validator;
+import jakarta.validation.ValidatorFactory;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+class AppConfigurationTest {
+
+    private Validator validator;
+
+    @BeforeEach
+    void setUp() {
+        ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
+        validator = factory.getValidator();
+    }
+
+    @DisplayName("Should return expected result")
+    @ParameterizedTest
+    @CsvSource("""
+            https://example.com, true,
+            https://example.ch, true,
+            null, false,
+            , false,
+            http://example.com, false,
+            https://.ch, false,
+            https://example.de, false,
+            https://e x am.ch, false
+            """)
+    void shouldReturnExpected(String input, boolean expectedValid) {
+        var config = new AppConfiguration(input);
+        var violations = validator.validate(config);
+
+        if (expectedValid) {
+            assertTrue(violations.isEmpty(), "Expected no violations for: " + input);
+        } else {
+            assertFalse(violations.isEmpty(), "Expected violations for: " + input);
+        }
+    }
+}

backend/src/test/java/ch/puzzle/pcts/controller/ConfigurationControllerIT.java

@@ -5,8 +5,11 @@
 import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
 import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
 
+import ch.puzzle.pcts.configuration.AppConfiguration;
 import ch.puzzle.pcts.configuration.AuthorizationConfiguration;
+import ch.puzzle.pcts.dto.appconfiguration.AppConfigurationDto;
 import ch.puzzle.pcts.dto.configuration.ConfigurationDto;
+import ch.puzzle.pcts.mapper.AppConfigurationMapper;
 import ch.puzzle.pcts.mapper.ConfigurationMapper;
 import ch.puzzle.pcts.util.JsonDtoMatcher;
 import java.util.List;
@@ -23,18 +26,28 @@ class ConfigurationControllerIT extends ControllerITBase {
     @MockitoBean
     private AuthorizationConfiguration authorizationConfiguration;
 
+    private static final String SUPPORT_URL = "https://example.com";
+
+    @MockitoBean
+    private AppConfiguration appConfiguration;
+
     @MockitoBean
-    private ConfigurationMapper mapper;
+    private ConfigurationMapper configMapper;
+
+    @MockitoBean
+    private AppConfigurationMapper appConfigurationMapper;
 
     @Autowired
     private MockMvc mvc;
 
     private static final String BASEURL = "/api/v1/configuration";
 
     private ConfigurationDto configurationDto;
+    private AppConfigurationDto appConfigurationDto;
 
     @BeforeEach
     void setUp() {
+        this.appConfigurationDto = new AppConfigurationDto("https://example.com");
         this.configurationDto = new ConfigurationDto(new ConfigurationDto.KeycloakDto("http://localhost:8544",
                                                                                       "pitc",
                                                                                       "pcts-dev",
@@ -44,12 +57,24 @@ void setUp() {
     @DisplayName("Should successfully get configuration")
     @Test
     void shouldSuccessfullyGetConfiguration() throws Exception {
-        when(mapper.toDto(authorizationConfiguration)).thenReturn(configurationDto);
+        when(configMapper.toDto(authorizationConfiguration)).thenReturn(configurationDto);
 
         mvc
-                .perform(get(BASEURL).with(csrf()).accept(MediaType.APPLICATION_JSON))
+                .perform(get(BASEURL + "/authorization").with(csrf()).accept(MediaType.APPLICATION_JSON))
                 .andExpect(status().isOk())
                 .andExpect(JsonDtoMatcher.matchesDto(configurationDto, "$"));
     }
 
+    @DisplayName("Should successfully get support page url")
+    @Test
+    void shouldSuccessfullyGetSupportPageUrl() throws Exception {
+        when(appConfiguration.getHelpUrl()).thenReturn(SUPPORT_URL);
+        when(appConfigurationMapper.toDto(SUPPORT_URL)).thenReturn(appConfigurationDto);
+
+        mvc
+                .perform(get(BASEURL + "/app").with(csrf()).accept(MediaType.APPLICATION_JSON))
+                .andExpect(status().isOk())
+                .andExpect(JsonDtoMatcher.matchesDto(appConfigurationDto, "$"));
+    }
+
 }

backend/src/test/resources/application-test.properties

@@ -10,6 +10,9 @@ app.member-sync.cron=0 0 3 * * ?
 app.member-sync.username=
 app.member-sync.password=
 
+# Support page url
+pcts.app.helpurl=https://google.com
+
 # OAuth
 spring.security.oauth2.resourceserver.jwt.issuer-uri=http://localhost:8544/realms/pitc
 spring.security.oauth2.resourceserver.jwt.jwk-set-uri=http://localhost:8544/realms/pitc/protocol/openid-connect/certs

frontend/cypress/e2e/topbar.cy.ts

@@ -0,0 +1,24 @@
+import * as users from '../fixtures/users.json';
+
+describe('Topbar', () => {
+  beforeEach(() => {
+    cy.loginAsUser(users.gl);
+  });
+
+  it('should have correct url set', () => {
+    cy.intercept('GET', 'http://localhost:4200/api/v1/configuration/app')
+      .as('getURL');
+
+    cy.visit('/');
+
+    cy.wait('@getURL');
+
+    cy.getByTestId('support-page-url')
+      .invoke('attr', 'href')
+      .then((href: string) => {
+        cy.get('@getURL.1')
+          .its('response.body.url')
+          .should('eq', href);
+      });
+  });
+});

frontend/public/i18n/de.json

@@ -1,6 +1,7 @@
 {
   "PCTS_LOGO_ALT": "Puzzle PCTS Logo",
   "LOGOUT": "Abmelden",
+  "HELP": "Hilfe",
   "DEGREE": {
     "MODEL_NAME": "Ausbildung",
     "NAME": "Bezeichnung"

frontend/src/app/app.component.html

@@ -12,6 +12,12 @@
   </pzsh-topbar>
   <pzsh-menu class="position-fixed z-3" data-testid="user-options">
     <div slot="actions">
+      <pzsh-menu-action>
+        <a class="text-reset text-decoration-none d-flex align-items-center" data-testid="support-page-url" href="{{ url() }}" target="_blank">
+          <pzsh-icon class="pe-1" name="question-circle"></pzsh-icon>
+          {{ "HELP" | translate }}
+        </a>
+      </pzsh-menu-action>
       <pzsh-menu-dropdown href="#">
         <div slot="toggle">
           <pzsh-icon name="user"></pzsh-icon>

frontend/src/app/app.component.ts

@@ -1,11 +1,12 @@
-import { Component, CUSTOM_ELEMENTS_SCHEMA, DOCUMENT, effect, inject } from '@angular/core';
+import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, DOCUMENT, effect, inject } from '@angular/core';
 import { Router, RouterOutlet } from '@angular/router';
 import '@puzzleitc/puzzle-shell';
 import { LangChangeEvent, TranslatePipe, TranslateService } from '@ngx-translate/core';
 import { NgOptimizedImage } from '@angular/common';
 import { toSignal } from '@angular/core/rxjs-interop';
 import { map } from 'rxjs';
 import { AuthService } from './core/auth/auth.service';
+import { ConfigurationService } from './features/configuration/configuration.service';
 
 @Component({
   selector: 'app-root',
@@ -23,6 +24,8 @@ export class AppComponent {
 
   protected readonly authService = inject(AuthService);
 
+  protected readonly configService = inject(ConfigurationService);
+
   private readonly translateService = inject(TranslateService);
 
   private readonly document = inject(DOCUMENT);
@@ -50,5 +53,6 @@ export class AppComponent {
       this.document.documentElement.setAttribute('lang', lang);
     }
   }
-}
 
+  url = computed(() => this.configService.helpURL.value()?.url);
+}

frontend/src/app/features/configuration/HelpUrl.model.ts

@@ -0,0 +1,3 @@
+export interface HelpUrlModel {
+  url: string;
+}

frontend/src/app/features/configuration/configuration.service.spec.ts

@@ -4,12 +4,14 @@ import { ConfigurationService } from './configuration.service';
 import { HttpTestingController, provideHttpClientTesting } from '@angular/common/http/testing';
 import { provideHttpClient } from '@angular/common/http';
 import { ConfigurationModel } from './configuration.model';
-import { configuration } from '../../shared/test/test-data';
+import { configuration, helpUrl } from '../../shared/test/test-data';
+import { HelpUrlModel } from './HelpUrl.model';
+import { firstValueFrom } from 'rxjs';
 
 describe('configurationService', () => {
   let httpMock: HttpTestingController;
   let service: ConfigurationService;
-  const API_URL = '/api/v1/configuration';
+  const API_URL = '/api/v1/configuration/';
 
   beforeEach(() => {
     TestBed.configureTestingModule({
@@ -32,19 +34,44 @@ describe('configurationService', () => {
   });
 
   describe('Configuration endpoint', () => {
-    it('should fetch configuration', () => {
+    it('should fetch configuration', async() => {
       const mockConfig: ConfigurationModel = configuration;
 
-      service.getConfiguration()
-        .subscribe((config) => {
-          expect(config)
-            .toEqual(mockConfig);
-        });
+      const config = service.getConfiguration<configuration>();
+
+      const configPromise = firstValueFrom(config);
+
+      const req = httpMock.expectOne(API_URL + 'authorization');
 
-      const req = httpMock.expectOne(API_URL);
       expect(req.request.method)
         .toBe('GET');
+
       req.flush(mockConfig);
+
+      expect(await configPromise)
+        .toEqual(mockConfig);
+
+      httpMock.verify();
+    });
+  });
+
+  describe('Supportpageurl endpoint', () => {
+    it('should fetch url', async() => {
+      const mockUrl: HelpUrlModel = helpUrl;
+
+      const url = firstValueFrom(service.getAppConfiguration());
+
+      const req = httpMock.expectOne(API_URL + 'app');
+
+      req.flush(mockUrl);
+
+      expect(await url)
+        .toEqual(mockUrl);
+
+      expect(req.request.method)
+        .toBe('GET');
+
+      httpMock.verify();
     });
   });
 });