feat: add help button #541

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

@@ -0,0 +1,21 @@
+package ch.puzzle.pcts.configuration;
+
+import jakarta.validation.constraints.NotBlank;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.validation.annotation.Validated;
+
+@Validated
+@ConfigurationProperties(prefix = "pcts.app.help")
+public record HelpUrlConfiguration(@NotBlank String url) {
+    public String helpUrl() {
+        if (isValid()) {
+            return url;
+        } else {
+            throw new IllegalStateException("Invalid support url configurated");
+        }
+    }
+
+    private boolean isValid() {
+        return url.startsWith("https://") && url.length() > 8 && !url.contains(" ") && !url.substring(8).isBlank();
+    }
+}

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

@@ -1,8 +1,11 @@
 package ch.puzzle.pcts.controller;
 
 import ch.puzzle.pcts.configuration.AuthorizationConfiguration;
+import ch.puzzle.pcts.configuration.HelpUrlConfiguration;
 import ch.puzzle.pcts.dto.configuration.ConfigurationDto;
+import ch.puzzle.pcts.dto.support.SupportDto;
 import ch.puzzle.pcts.mapper.ConfigurationMapper;
+import ch.puzzle.pcts.mapper.SupportMapper;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.GetMapping;
@@ -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 SupportMapper supportMapper;
     private final AuthorizationConfiguration authConfig;
+    private final HelpUrlConfiguration helpUrlConfig;
 
-    public ConfigurationController(ConfigurationMapper mapper, AuthorizationConfiguration authConfig) {
-        this.mapper = mapper;
+    public ConfigurationController(ConfigurationMapper configMapper, SupportMapper supportMapper,
+                                   AuthorizationConfiguration authConfig, HelpUrlConfiguration helpUrlConfig) {
+        this.configMapper = configMapper;
+        this.supportMapper = supportMapper;
         this.authConfig = authConfig;
+        this.helpUrlConfig = helpUrlConfig;
     }
 
-    @GetMapping
+    @GetMapping("/authorization")
     public ResponseEntity<ConfigurationDto> getAuthorizationConfiguration() {
-        return ResponseEntity.ok(mapper.toDto(this.authConfig));
+        return ResponseEntity.ok(configMapper.toDto(this.authConfig));
+    }
+
+    @GetMapping("/help")
+    public ResponseEntity<SupportDto> getHelpUrl() {
+        return ResponseEntity.ok(supportMapper.toDto(this.helpUrlConfig.helpUrl()));
     }
 }

backend/src/main/java/ch/puzzle/pcts/dto/support/SupportDto.java

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

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

@@ -0,0 +1,11 @@
+package ch.puzzle.pcts.mapper;
+
+import ch.puzzle.pcts.dto.support.SupportDto;
+import org.springframework.stereotype.Component;
+
+@Component
+public class SupportMapper {
+    public SupportDto toDto(String url) {
+        return new SupportDto(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.help.url=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.help.url=https://dummy-url.test
+
 # 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/HelpUrlConfigurationTest.java

@@ -0,0 +1,59 @@
+package ch.puzzle.pcts.configuration;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class HelpUrlConfigurationTest {
+    @DisplayName("Should throw exception when url does not start with https://")
+    @Test
+    void shouldThrowExceptionWhenUrlDoesNotStartWithHttps() {
+        String url = "http://example.com";
+
+        var config = new HelpUrlConfiguration(url);
+
+        assertThrows(IllegalStateException.class, () -> config.helpUrl());
+    }
+
+    @DisplayName("Should throw exception when url ends after https:// so when length is not over 8")
+    @Test
+    void shouldThrowExceptionWhenUrlIsNotLongerThan8Chars() {
+        String url = "https://";
+
+        var config = new HelpUrlConfiguration(url);
+
+        assertThrows(IllegalStateException.class, () -> config.helpUrl());
+    }
+
+    @DisplayName("Should throw exception when url contains a space")
+    @Test
+    void shouldThrowExceptionWhenUrlContainsSpace() {
+        String url = "https://in validUrl.com";
+
+        var config = new HelpUrlConfiguration(url);
+
+        assertThrows(IllegalStateException.class, () -> config.helpUrl());
+    }
+
+    @DisplayName("Should throw exception when url is blank after index 8")
+    @Test
+    void shouldThrowExceptionWhenUrlIsBlankAfterIndex8() {
+        String url = "https://   ";
+
+        var config = new HelpUrlConfiguration(url);
+
+        assertThrows(IllegalStateException.class, () -> config.helpUrl());
+    }
+
+    @DisplayName("Should return correct url a valid url is configured")
+    @Test
+    void shouldReturnCorrectUrlWhenUrlIsValid() {
+        String url = "https://example.com";
+
+        var config = new HelpUrlConfiguration(url);
+
+        assertEquals(url, config.helpUrl());
+    }
+}

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

@@ -6,8 +6,11 @@
 import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
 
 import ch.puzzle.pcts.configuration.AuthorizationConfiguration;
+import ch.puzzle.pcts.configuration.HelpUrlConfiguration;
 import ch.puzzle.pcts.dto.configuration.ConfigurationDto;
+import ch.puzzle.pcts.dto.support.SupportDto;
 import ch.puzzle.pcts.mapper.ConfigurationMapper;
+import ch.puzzle.pcts.mapper.SupportMapper;
 import ch.puzzle.pcts.util.JsonDtoMatcher;
 import java.util.List;
 import org.junit.jupiter.api.BeforeEach;
@@ -23,30 +26,52 @@ class ConfigurationControllerIT extends ControllerITBase {
     @MockitoBean
     private AuthorizationConfiguration authorizationConfiguration;
 
+    private static final String supportUrl = "https://example.com";
+
+    @MockitoBean
+    private HelpUrlConfiguration helpUrlConfiguration;
+
     @MockitoBean
-    private ConfigurationMapper mapper;
+    private ConfigurationMapper configMapper;
+
+    @MockitoBean
+    private SupportMapper supportMapper;
 
     @Autowired
     private MockMvc mvc;
 
     private static final String BASEURL = "/api/v1/configuration";
 
     private ConfigurationDto configurationDto;
+    private SupportDto supportDto;
 
     @BeforeEach
     void setUp() {
         this.configurationDto = new ConfigurationDto(List.of("ADMIN_1", "ADMIN_2"));
+        this.supportDto = new SupportDto("https://example.com");
     }
 
     @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(helpUrlConfiguration.helpUrl()).thenReturn(supportUrl);
+        when(supportMapper.toDto(supportUrl)).thenReturn(supportDto);
+
+        mvc
+                .perform(get(BASEURL + "/help").with(csrf()).accept(MediaType.APPLICATION_JSON))
+                .andExpect(status().isOk())
+                .andExpect(JsonDtoMatcher.matchesDto(supportDto, "$"));
+    }
+
 }

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.help.url=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,13 @@
+import * as users from '../fixtures/users.json';
+
+describe('Topbar', () => {
+  beforeEach(() => {
+    cy.loginAsUser(users.gl);
+    cy.visit('/');
+  });
+
+  it('should have correct url on help', () => {
+    cy.get('#support-page-url')
+      .should('have.attr', 'href', 'https://dummy-url.test');
+  });
+});

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,14 +12,21 @@
   </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" id="support-page-url" 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>
           {{ authService.name() }}
         </div>
         <div slot="items">
           <pzsh-menu-dropdown-item href="#">
-            <button class="bg-transparent border-0 p-0 shadow-none text-reset d-inline-flex align-items-center" (click)="handleLogout()" data-testid="logout">
+            <button class="bg-transparent border-0 p-0 shadow-none text-reset d-inline-flex align-items-center"
+                    (click)="handleLogout()" data-testid="logout">
               <pzsh-icon name="sign-out-alt"></pzsh-icon>
               {{ "LOGOUT" | translate }}
             </button>

frontend/src/app/app.component.ts

@@ -1,11 +1,12 @@
-import { Component, CUSTOM_ELEMENTS_SCHEMA, DOCUMENT, effect, inject } from '@angular/core';
+import { Component, CUSTOM_ELEMENTS_SCHEMA, DOCUMENT, effect, inject, signal } 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);
@@ -31,10 +34,17 @@ export class AppComponent {
     initialValue: this.translateService.getCurrentLang() || this.translateService.getFallbackLang() || this.translateService.getBrowserLang() || 'en'
   });
 
+  readonly url = signal<string>('');
+
   constructor() {
     effect(() => {
       this.setHtmlLangAttribute(this.currentLang());
     });
+
+    this.configService.getHelpUrl()
+      .subscribe((response) => {
+        this.url.set(response.url);
+      });
   }
 
   visitRoot(): void {
@@ -51,4 +61,3 @@ export class AppComponent {
     }
   }
 }
-

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,13 @@ 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';
 
 describe('configurationService', () => {
   let httpMock: HttpTestingController;
   let service: ConfigurationService;
-  const API_URL = '/api/v1/configuration';
+  const API_URL = '/api/v1/configuration/authorization';
 
   beforeEach(() => {
     TestBed.configureTestingModule({
@@ -47,4 +48,21 @@ describe('configurationService', () => {
       req.flush(mockConfig);
     });
   });
+
+  describe('Supportpageurl endpoint', () => {
+    it('should fetch url', () => {
+      const mockUrl: HelpUrlModel = helpUrl;
+
+      service.getConfiguration()
+        .subscribe((response) => {
+          expect(response)
+            .toEqual(mockUrl);
+        });
+
+      const req = httpMock.expectOne(API_URL);
+      expect(req.request.method)
+        .toBe('GET');
+      req.flush(mockUrl);
+    });
+  });
 });