Revize fd5ab42e

Refactor service structure

webapp/src/app/dashboard/employer-dashboard/employer-dashboard.component.ts

@@ -1 +1 @@
 import {Component, Input, OnInit} from '@angular/core';
 import {MatDialog} from '@angular/material';
 import {AddDaysOffDialogComponent} from '../../add-days-off-dialog/add-days-off-dialog.component';
-import {UsersService} from '../../services/users.service';
+import {UsersService} from '../../services/api/users.service';
 import {Requests} from '../../models/requests.model';
-import {UserService} from '../../services/user.service';
-import {ProfileService} from '../../services/profile.service';
+import {UserService} from '../../services/api/user.service';
+import {ProfileService} from '../../services/api/profile.service';
 import {UserProfile} from '../../models/user.model';
 
 @Component({

webapp/src/app/employees/employees-list.component.ts

@@ -1 +1 @@
 import {Component, OnInit} from '@angular/core';
-import {UsersService} from '../services/users.service';
+import {UsersService} from '../services/api/users.service';
 import {Languages, VacationType} from '../enums/common.enum';
 import {MatDialog, MatSnackBar} from '@angular/material';
 import {EditEmployeeDialogComponent} from './edit-employee-dialog/edit-employee-dialog.component';
@@ -7 +7 @@
 import {UserBasicInformation, UserProfile} from '../models/user.model';
 import {DefaultSettingsDialogComponent} from './default-settings-dialog/default-settings-dialog.component';
 import {Settings} from '../models/settings.model';
-import {SettingsService} from '../services/settings.service';
-import {UserService} from '../services/user.service';
+import {SettingsService} from '../services/api/settings.service';
+import {UserService} from '../services/api/user.service';
 import {LocalizationService} from '../localization/localization.service';
-import {DateFormatterService} from '../shared/date-formatter.service';
+import {DateFormatterService} from '../services/util/date-formatter.service';
 
 const daysOfWeek: string[] = [
   'po',
@@ -78 +78 @@
           })
           .afterClosed().subscribe(data => {
             if (data && data.isConfirmed) {
-              // TODO API CALL
-              // this.settingsService.postDefaultSettingsWithLanguage(this.toSettings(data), this.localizationService.getCurrentLanguage());
+              this.settingsService.postDefaultSettingsWithLanguage(this.toSettings(data), this.localizationService.getCurrentLanguage())
+                .subscribe((foo: any) => console.log(foo));
             }
           });
       });

webapp/src/app/header/header.component.ts

@@ -1 +1 @@
 import { Component, Input } from '@angular/core';
 import { MatDialog } from '@angular/material';
 import { ProfileSettingsComponent } from '../profile-settings/profile-settings.component';
-import { ProfileService } from '../services/profile.service';
+import { ProfileService } from '../services/api/profile.service';
 import {LocalizationService} from '../localization/localization.service';
 
 @Component({

webapp/src/app/menu/menu.component.ts

@@ -1 +1 @@
 import { Component, OnInit } from '@angular/core';
-import { MenuService } from '../services/menu.service';
 import { MenuItem } from './menu-item';
 
+const MENU_ITEMS: MenuItem[] = [
+  {name: 'Dashboard', routePath: 'dashboard'},
+  {name: 'Zaměstnanci', routePath: 'employees'},
+];
+
 @Component({
   selector: 'app-menu',
   templateUrl: './menu.component.html',
@@ -11 +15 @@
   _menuItems: MenuItem[];
   private _selectedMenuItem: MenuItem;
 
+  constructor() {
+    this._menuItems = MENU_ITEMS;
+  }
 
-  getMenuItems(): void {
-    this.menuService.getMenuItems()
-      .subscribe(menuItems => this._menuItems = menuItems);
+  ngOnInit() {
   }
 
   onSelect(menuItem: MenuItem): void {
     this._selectedMenuItem = menuItem;
   }
-
-  constructor(private menuService: MenuService) { }
-
-  ngOnInit() {
-    this.getMenuItems();
-  }
-
-
 }

webapp/src/app/mock-menu-items.ts

@@ -1 @@
-import { MenuItem } from './menu/menu-item';
-
-export const MENU_ITEMS: MenuItem[] = [
-  {name: 'Dashboard', routePath: 'dashboard'},
-  {name: 'Zaměstnanci', routePath: 'employees'},
-];

webapp/src/app/oncoming-days-off/oncoming-days-off.component.ts

@@ -1 +1 @@
 import {Component, OnInit} from '@angular/core';
-import {UserService} from '../services/user.service';
+import {UserService} from '../services/api/user.service';
 import {VacationType} from '../enums/common.enum';
 
 @Component({

webapp/src/app/services/api/basic.service.ts

@@ +1 @@
+import {Injectable} from '@angular/core';
+import {HttpClient, HttpErrorResponse, HttpParams} from '@angular/common/http';
+import {throwError} from 'rxjs';
+import {environment} from '../../../environments/environment';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class BasicService {
+  protected baseUrl = environment.apiUrl;
+
+  constructor(protected http: HttpClient) { }
+
+  protected handleError(error: HttpErrorResponse) {
+    if (error.error instanceof ErrorEvent) {
+      console.error('An error occurred:', error.error.message);
+    } else {
+      console.error(
+        `Backend returned code ${error.status}, ` +
+        `body was: ${error.error}`);
+    }
+    return throwError(
+      'Something bad happened; please try again later.');
+  }
+
+  protected createParams(params: any) {
+    let httpParams = new HttpParams();
+    for (const key in params) {
+      if (params.hasOwnProperty(key)) {
+        if (params[key] != null) {
+          httpParams = httpParams.set(key, params[key]);
+        }
+      }
+    }
+
+    return httpParams;
+  }
+}

webapp/src/app/services/api/profile.service.ts

@@ +1 @@
+import {Injectable} from '@angular/core';
+import {UserService} from './user.service';
+import {Observable} from 'rxjs';
+import {UserProfile} from '../../models/user.model';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class ProfileService {
+  private profile: UserProfile;
+
+  constructor(
+    private userService: UserService
+  ) {
+    // userService.getUserProfile(1)
+    //   .subscribe((data: UserProfile) => this.profile = data);
+  }
+
+  getProfile(): Observable<UserProfile> {
+    return new Observable((observer) => {
+      if (this.profile) {
+        observer.next(this.profile);
+        observer.complete();
+      } else {
+        this.userService.getUserProfile(1) // TODO zmenit id na prihlaseneho uzivatele
+          .subscribe((data: UserProfile) => {
+            this.profile = data;
+            observer.next(this.profile);
+            observer.complete();
+          });
+      }
+    });
+  }
+
+}

webapp/src/app/services/api/settings.service.ts

@@ +1 @@
+import { Injectable } from '@angular/core';
+import {HttpClient, HttpParams} from '@angular/common/http';
+import { catchError } from 'rxjs/operators';
+
+import { BasicService } from './basic.service';
+import { Settings } from '../../models/settings.model';
+import {Languages} from '../../enums/common.enum';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class SettingsService extends BasicService {
+  defaultSettingsUrl = this.baseUrl + '/api/settings';
+
+  constructor(protected http: HttpClient) {
+    super(http);
+  }
+
+  /**
+   * Returns default application settings
+   * with sickday count and notification
+   */
+  getDefaultSettings() {
+    return this.makeGetSettingsApiCall(null);
+  }
+
+  /**
+   * Returns default application settings
+   * with sickday count and notification
+   * @param language filter by language
+   */
+  getDefaultSettingsWithLanguage(language: Languages) {
+    return this.makeGetSettingsApiCall(language);
+  }
+
+  /**
+   * Získání aktuálně použitého výchozího nastavení v aplikaci
+   * GET /setttings?[lang=<CZ,EN>]
+   * @param language filter with language
+   */
+  private makeGetSettingsApiCall(language: string) {
+    const httpParams: HttpParams = this.createParams({lang: language});
+    const options = {params: httpParams};
+
+    return this.http.get<Settings>(this.defaultSettingsUrl, options)
+      .pipe(
+        catchError(err => this.handleError(err))
+      );
+  }
+
+  postDefaultSettings(settings: Settings) {
+    return this.postDefaultSettingsWithOptions(settings, null);
+  }
+
+  postDefaultSettingsWithLanguage(settings: Settings, language: Languages) {
+    return this.postDefaultSettingsWithOptions(settings, language);
+  }
+
+  private postDefaultSettingsWithOptions(settings: Settings, language: Languages) {
+    const httpParams: HttpParams = this.createParams({lang: language});
+    const options = {params: httpParams};
+
+    return this.http.post<Settings>(this.defaultSettingsUrl, settings, options)
+      .pipe(
+        catchError(err => this.handleError(err))
+      );
+  }
+}

webapp/src/app/services/api/user.service.ts

@@ +1 @@
+import {Injectable} from '@angular/core';
+import {HttpClient, HttpParams} from '@angular/common/http';
+
+import {Calendar, CalendarEdit, PostCalendar} from '../../models/calendar.model';
+import {BasicService} from './basic.service';
+import {catchError} from 'rxjs/operators';
+import {Languages, RequestStatus, RequestTypes} from '../../enums/common.enum';
+import {UserSettings} from '../../models/settings.model';
+import {UserProfile} from '../../models/user.model';
+import {UserRequest} from '../../models/requests.model';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class UserService extends BasicService { // dost podobny k usersService, mozna zmenit v rest api
+  private _userUrl = this.baseUrl + '/api/user/';
+
+  constructor(protected http: HttpClient) {
+    super(http);
+  }
+
+  /**
+   * Returns user profile if the user making this call
+   * is logged as admin
+   * UserProfile.notification might be returned as string instead of date
+   * @param id employee id
+   */
+  getUserProfile(id: number) {
+    return this.makeGetProfileApiCall(id.toString(), null);
+  }
+
+  /**
+   * Overloaded version of getUserProfile to filter profiles
+   * by language
+   * UserProfile.notification might be returned as string instead of date
+   * @param id user profile id
+   * @param language language to filtery by
+   */
+  getUserProfileWithLanguage(id: number, language: Languages) {
+    return this.makeGetProfileApiCall(id.toString(), language);
+  }
+
+  /**
+   * Returns profile of currently logged user
+   * UserProfile.notification might be returned as string instead of date
+   */
+  getLoggedUserProfile() {
+    return this.makeGetProfileApiCall('me', null);
+  }
+
+  /**
+   * Returns profile of currently logged user filtered by language
+   * UserProfile.notification might be returned as string instead of date
+   * @param language filter profile by language
+   */
+  getLoggedUserProfileWithLanguage(language: Languages) {
+    return this.makeGetProfileApiCall('me', language);
+  }
+
+  /**
+   * Returns vacation and sick days from the given date
+   * for logged user
+   * @param from returns days from this date forward
+   */
+  getLoggedUserCalendar(from: Date) {
+    return this.makeGetCalendarApiCall('me', from, null, null, null);
+  }
+
+  /**
+   * Returns vacation and sick days from the given date
+   * for logged user
+   * @param from returns days from this date forward
+   * @param to limit returned days, returns <from, to>
+   * @param language filter by language
+   * @param status filter by status
+   */
+  getLoggedUserCalendarWithOptions(from: Date, to: Date, language: Languages, status: RequestStatus) {
+    return this.makeGetCalendarApiCall('me', from, to, language, status);
+  }
+
+  /**
+   * Post user calendar using POST
+   * @param calendar to be posted
+   */
+  postCalendar(calendar: PostCalendar) {
+    return this.makePostCalendarApiCall(calendar, null);
+  }
+
+  /**
+   * Post user calendar using POST with specified language
+   * @param calendar to be posted
+   * @param language specified language
+   */
+  postCalendarWithLanguage(calendar: PostCalendar, language: Languages) {
+    return this.makePostCalendarApiCall(calendar, language);
+  }
+
+  /**
+   * Put user settings with given id for the user
+   * @param settings settings to be put
+   */
+  putUserSettings(settings: UserSettings) {
+    return this.makePutUserSettingsApiCall(settings, null);
+  }
+
+  /**
+   * Put user settings with given id for the user
+   * @param settings settings to be put
+   * @param language specified language
+   */
+  putUserSettingsWithLanguage(settings: UserSettings, language: Languages) {
+    return this.makePutUserSettingsApiCall(settings, language);
+  }
+
+  /**
+   * Accept or deny user request
+   * @param request request to accept or deny
+   * @param type request type
+   */
+  putUserRequest(request: UserRequest, type: RequestTypes) {
+    return this.makePutUserRequestApiCall(request, type, null);
+  }
+
+  /**
+   * Accept or deny user request
+   * @param request request to accept or deny
+   * @param type reqeust type
+   * @param language specify language
+   */
+  putUserRequestWithLanguage(request: UserRequest, type: RequestTypes, language: Languages) {
+    return this.makePutUserRequestApiCall(request, type, language);
+  }
+
+  /**
+   * Edit calendar
+   * @param calendarEdit calendar day to be edited
+   * @param language specify language
+   */
+  putCalendarEdit(calendarEdit: CalendarEdit, language: Languages) {
+    return this.makePutCalendarEditApiCall(calendarEdit, null);
+  }
+
+  /**
+   * Delete calendar vacation day with given id
+   * @param id calendar day id to be deleted
+   * @param language specify language
+   */
+  deleteCalendar(id: number, language: Languages) {
+    return this.makeDeleteCalendarApiCall(id, language);
+  }
+
+  /**
+   * Získání profilu aktuálně přihlášeného uživatele nebo uživatele podle zadaného id.
+   * GET /user/<{id} || me>/profile?[lang=<CZ,EN>]
+   * @param id id of profile to get (number or 'me')
+   * @param language filter by language
+   */
+  private makeGetProfileApiCall(id: string, language: string) {
+    const httpParams: HttpParams = this.createParams({lang: language});
+    const options = {params: httpParams};
+
+    return this.http.get<UserProfile>(this._userUrl + id + '/profile', options)
+      .pipe(
+        catchError(err => this.handleError(err))
+      );
+  }
+
+  /**
+   * Získání dovolené a sick days v zadaném období. Pokud není zadán parameter “to” vrátí všechny dovolené a sick days od “from”. Navíc umožňuje filtrovat pomocí statusu schválení.
+   * GET /user/<{id} || me>/calendar?[lang=<CZ,EN>]&from=yyyy/mm/dd, [to=yyyy/mm/dd], [status=<ACCEPTED, PENDING, REJECTED>]
+   * @param id id of calendar to get (number or 'me')
+   * @param from mandatory param
+   * @param to upper limit of days
+   * @param language filter by language
+   * @param status filter by status
+   */
+  private makeGetCalendarApiCall(id: string, from: Date, to: Date, language: Languages, status: RequestStatus) {
+    const fromString: string = from.getFullYear() + '/' + from.getMonth() + '/' + from.getDate();
+    let toString: string;
+    if (to != null) {
+      toString = to.getFullYear() + '/' + to.getMonth() + '/' + to.getDate();
+    }
+
+    const httpParams: HttpParams = this.createParams({lang: language, from: fromString, to: toString, status});
+    const options = {params: httpParams};
+
+    return this.http.get<Calendar[]>(this._userUrl + id + '/calendar', options)
+      .pipe(
+        catchError(err => this.handleError(err))
+      );
+  }
+
+  /**
+   * Povolení nebo zamítnutí žádosti nebo “smazání“ uživatele (změna statusu na REJECTED)
+   * PUT /user/requests?[lang=<CZ,EN>]&type=<VACATION, AUTHORIZATION>
+   * @param request request to accept or reject
+   * @param reqType request type
+   * @param language specify language
+   */
+  private makePutUserRequestApiCall(request: UserRequest, reqType: RequestTypes, language: Languages) {
+    const httpParams: HttpParams = this.createParams({type: reqType, lang: language});
+    const options = {params: httpParams};
+
+    return this.http.put<UserRequest>(this._userUrl + 'requests', request, options)
+      .pipe(
+        catchError(err => this.handleError(err))
+      );
+  }
+
+
+  /**
+   * Změna nastavení uživatele podle id
+   * PUT /user/settings?[lang=<CZ,EN>]
+   * @param settings setting to be set for given user
+   * @param language specified language
+   */
+  private makePutUserSettingsApiCall(settings: UserSettings, language: Languages) {
+    const httpParams: HttpParams = this.createParams({lang: language});
+    const options = {params: httpParams};
+
+    return this.http.put<UserSettings>(this._userUrl + 'settings', settings, options)
+      .pipe(
+        catchError(err => this.handleError(err))
+      );
+  }
+
+  /**
+   * Vytvoření nové dovolené nebo sick day
+   * POST /user/calendar/create?[lang=<CZ,EN>]
+   * @param calendar calendar to be posted
+   * @param language specified language
+   */
+  private makePostCalendarApiCall(calendar: PostCalendar, language: Languages) {
+    const httpParams: HttpParams = this.createParams({lang: language});
+    const options = {params: httpParams};
+
+    return this.http.post<PostCalendar>(this._userUrl + 'calendar/create', calendar, options)
+      .pipe(
+        catchError(err => this.handleError(err))
+      );
+
+  }
+
+  /**
+   * Smazání dovolené nebo sickday podle jejího id
+   * DELETE /calendar/delete?[lang=<CZ,EN>]
+   * @param id id of calendar to delete
+   * @param language specify language
+   */
+  private makeDeleteCalendarApiCall(id: number, language: Languages) {
+    const httpParams: HttpParams = this.createParams({lang: language});
+    const options = {params: httpParams};
+
+    return this.http.delete(this._userUrl + 'calendar/' + id + '/delete', options)
+      .pipe(
+        catchError(err => this.handleError(err))
+      );
+  }
+
+  /**
+   * Editace dovolené nebo sickday podle jejího id
+   * PUT /calendar/edit?[lang=<CZ,EN>]
+   * @param calendarEdit calendar to edit
+   * @param language specify language
+   */
+  private makePutCalendarEditApiCall(calendarEdit: CalendarEdit, language: Languages) {
+    const httpParams: HttpParams = this.createParams({lang: language});
+    const options = {params: httpParams};
+
+    return this.http.put<CalendarEdit>(this._userUrl + 'calendar/edit', calendarEdit, options)
+      .pipe(
+        catchError(err => this.handleError(err))
+      );
+  }
+}

webapp/src/app/services/api/users.service.ts

@@ +1 @@
+import {Injectable} from '@angular/core';
+import {HttpClient, HttpParams} from '@angular/common/http';
+import {BasicService} from './basic.service';
+import {catchError} from 'rxjs/operators';
+
+import {AuthorizationRequest, VacationRequest} from '../../models/requests.model';
+import {Languages, ProfileStatus} from '../../enums/common.enum';
+import {Observable} from 'rxjs';
+import {UserBasicInformation} from '../../models/user.model';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class UsersService extends BasicService {
+  private _usersUrl = this.baseUrl + '/api/users';
+
+  constructor(protected http: HttpClient) {
+    super(http);
+  }
+
+  /**
+   * Returns all authorized users
+   */
+  getAuthorizedUsers() {
+    return this.makeGetUsersApiCall(ProfileStatus.AUTHORIZED, null);
+  }
+
+  /**
+   * Returns all authorized users with specified language
+   * overloaded version of getAuthorizedUsers
+   * @param language filter users based on language
+   */
+  getAuthorizedUsersWithLanguage(language: Languages) {
+    return this.makeGetUsersApiCall(ProfileStatus.AUTHORIZED, language);
+  }
+
+  /**
+   * Returns all pending users
+   */
+  getPendingUsers() {
+    return this.makeGetUsersApiCall(ProfileStatus.PENDING, null);
+  }
+
+  /**
+   * Returns all pending users with specified language
+   * overloaded version of getPendingUsers
+   * @param language filter users based on language
+   */
+  getPendingUsersWithLanguage(language: Languages) {
+    return this.makeGetUsersApiCall(ProfileStatus.PENDING, language);
+  }
+
+  /**
+   * Return all rejected users
+   */
+  getRejectedUsers() {
+    return this.makeGetUsersApiCall(ProfileStatus.REJECTED, null);
+  }
+
+  /**
+   * Returns all rejected users with specified language
+   * overloaded version of getRejectedUsers
+   * @param language filter users based on language
+   */
+  getRejectedUsersWithLanguage(language: Languages) {
+    return this.makeGetUsersApiCall(ProfileStatus.REJECTED, language);
+  }
+
+ /**
+  * Default api call which returns all users in the database
+  * regardless of language and status
+  */
+  getUsers() {
+    return this.makeGetUsersApiCall(null, null);
+  }
+
+  /**
+   * Returns all vacation requests
+   */
+  getVacationRequests() {
+    return this.makeGetVacationRequestsApiCall(null);
+  }
+
+  /**
+   * Returns vacations filtered by language
+   * @param language filter by passed language
+   */
+  getVacationRequestsWithLanguage(language: Languages) {
+    return this.makeGetVacationRequestsApiCall(language);
+  }
+
+
+  /**
+   * Returns all authorization requests
+   */
+  getAuthorizationRequests() {
+    return this.makeGetAuthorizationRequestsApiCall(null);
+  }
+
+
+  /**
+   * Returns authorization requests filtered by language
+   * @param language filter by passed language
+   */
+  getAuthorizationRequestsWithLanguage(language: Languages) {
+    return this.makeGetAuthorizationRequestsApiCall(language);
+  }
+
+  /**
+   * Získání žádostí o autorizaci všech uživatelů s možností filtrace pomocí úrovně schválení.
+   * GET /users/requests/authorization?[lang=<CZ,EN>]&[status=<ACCEPTED, PENDING, REJECTED>
+   * @param language filter by language
+   */
+  private makeGetAuthorizationRequestsApiCall(language: string) {
+    const httpParams: HttpParams = this.createParams({lang: language});
+    const options = {params: httpParams};
+
+    return this.http.get<AuthorizationRequest[]>(this._usersUrl + '/requests/authorization', options)
+      .pipe(
+        catchError(err => this.handleError(err))
+      );
+  }
+
+  /**
+   * Získání žádostí o dovolené a sick days všech uživatelů s možností filtrace pomocí úrovně schválení.
+   * GET /users/requests/vacation? [lang=<CZ,EN>]&[status=<ACCEPTED, PENDING, REJECTED>]
+   * @param language filter by language
+   */
+  private makeGetVacationRequestsApiCall(language: string) {
+    const httpParams: HttpParams = this.createParams({lang: language});
+    const options = {params: httpParams};
+
+    return this.http.get<VacationRequest[]>(this._usersUrl + '/requests/vacation', options)
+      .pipe(
+        catchError(err => this.handleError(err))
+      );
+  }
+
+  /**
+   * Získání všech uživatelů s možností filtrace pomocí statusu
+   * GET /users?[lang=<CZ,EN>]&[status=<ACCEPTED, PENDING, REJECTED>]
+   * @param status filter by status
+   * @param language filter by language
+   */
+  private makeGetUsersApiCall(status: string, language: string): Observable<UserBasicInformation[]> {
+    const httpParams: HttpParams = this.createParams({lang: language, status});
+    const options = {params: httpParams};
+
+    return this.http.get<UserBasicInformation[]>(this._usersUrl, options)
+      .pipe(
+        catchError(err => this.handleError(err))
+      );
+  }
+
+}

webapp/src/app/services/basic.service.ts

@@ -1 @@
-import {Injectable} from '@angular/core';
-import {HttpClient, HttpErrorResponse, HttpParams} from '@angular/common/http';
-import {throwError} from 'rxjs';
-import {environment} from '../../environments/environment';
-
-@Injectable({
-  providedIn: 'root'
-})
-export class BasicService {
-  protected baseUrl = environment.apiUrl;
-
-  constructor(protected http: HttpClient) { }
-
-  protected handleError(error: HttpErrorResponse) {
-    if (error.error instanceof ErrorEvent) {
-      console.error('An error occurred:', error.error.message);
-    } else {
-      console.error(
-        `Backend returned code ${error.status}, ` +
-        `body was: ${error.error}`);
-    }
-    return throwError(
-      'Something bad happened; please try again later.');
-  }
-
-  protected createParams(params: any) {
-    let httpParams = new HttpParams();
-    for (const key in params) {
-      if (params.hasOwnProperty(key)) {
-        if (params[key] != null) {
-          httpParams = httpParams.set(key, params[key]);
-        }
-      }
-    }
-
-    return httpParams;
-  }
-}

webapp/src/app/services/menu.service.ts

@@ -1 @@
-import { Injectable } from '@angular/core';
-import { MenuItem } from '../menu/menu-item';
-import { Observable, of } from 'rxjs';
-import { MENU_ITEMS } from '../mock-menu-items';
-
-@Injectable({
-  providedIn: 'root'
-})
-export class MenuService {
-
-  getMenuItems(): Observable<MenuItem[]> {
-    return of(MENU_ITEMS);
-  }
-
-  constructor() { }
-}

webapp/src/app/services/profile.service.ts

@@ -1 @@
-import {Injectable} from '@angular/core';
-import {UserService} from './user.service';
-import {Observable} from 'rxjs';
-import {UserProfile} from '../models/user.model';
-
-@Injectable({
-  providedIn: 'root'
-})
-export class ProfileService {
-  private profile: UserProfile;
-
-  constructor(
-    private userService: UserService
-  ) {
-    // userService.getUserProfile(1)
-    //   .subscribe((data: UserProfile) => this.profile = data);
-  }
-
-  getProfile(): Observable<UserProfile> {
-    return new Observable((observer) => {
-      if (this.profile) {
-        observer.next(this.profile);
-        observer.complete();
-      } else {
-        this.userService.getUserProfile(1) // TODO zmenit id na prihlaseneho uzivatele
-          .subscribe((data: UserProfile) => {
-            this.profile = data;
-            observer.next(this.profile);
-            observer.complete();
-          });
-      }
-    });
-  }
-
-}

webapp/src/app/services/settings.service.spec.ts

@@ -1 @@
-import {TestBed} from '@angular/core/testing';
-
-import {HttpClientTestingModule, HttpTestingController} from '@angular/common/http/testing';
-import {environment} from '../../environments/environment';
-import {SettingsService} from './settings.service';
-import {Languages} from '../enums/common.enum';
-
-describe('SettingsService', () => {
-  let service: SettingsService;
-  let httpMock: HttpTestingController;
-  const baseUrl: string = environment.apiUrl;
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      imports: [HttpClientTestingModule],
-      providers: [SettingsService]
-    });
-
-    service = TestBed.get(SettingsService);
-    httpMock = TestBed.get(HttpTestingController);
-  });
-  afterEach(() => httpMock.verify());
-
-  it('getDefaultSettings', () => {
-    const dummyData = {
-      sickdayCount: 3,
-      notification: '2019/05/25 14:41:31'
-    };
-
-    service.getDefaultSettings().subscribe((data: any) => {
-      expect(data.sickdayCount).toBeDefined();
-      expect(data.sickdayCount).toBe(3);
-      expect(data.notification).toBeDefined();
-    });
-
-    const req = httpMock.expectOne(baseUrl + '/api/settings');
-    expect(req.request.method).toBe('GET');
-    req.flush(dummyData);
-  });
-
-  it('getDefaultSettingsWithLanguage', () => {
-    const dummyData = {
-      sickdayCount: 3,
-      notification: '2019/05/25 14:41:31'
-    };
-
-    service.getDefaultSettingsWithLanguage(Languages.ENGLISH).subscribe((data: any) => {
-      expect(data.sickdayCount).toBeDefined();
-      expect(data.sickdayCount).toBe(3);
-      expect(data.notification).toBeDefined();
-    });
-
-    const req = httpMock.expectOne(baseUrl + '/api/settings?lang=EN');
-    expect(req.request.method).toBe('GET');
-    req.flush(dummyData);
-  });
-
-
-  it('postDefaultSettings', () => {
-    const dummyAnswer = {
-      answer: 'ok',
-    };
-
-    service.postDefaultSettings({sickdayCount: 3, notification: '2019/04/25 18:23:36'})
-      .subscribe((data: any) => expect(data.answer).toBe('ok'));
-
-    const req = httpMock.expectOne(baseUrl + '/api/settings');
-    expect(req.request.method).toBe('POST');
-    req.flush(dummyAnswer);
-  });
-
-  it('postDefaultSettingsWithLanguage', () => {
-    const dummyAnswer = {
-      answer: 'ok',
-    };
-
-    service.postDefaultSettingsWithLanguage({sickdayCount: 3, notification: '2019/04/25 18:23:36'}, Languages.ENGLISH)
-      .subscribe((data: any) => expect(data.answer).toBe('ok'));
-
-    const req = httpMock.expectOne(baseUrl + '/api/settings?lang=EN');
-    expect(req.request.method).toBe('POST');
-    req.flush(dummyAnswer);
-  });
-
-});

webapp/src/app/services/settings.service.ts

@@ -1 @@
-import { Injectable } from '@angular/core';
-import {HttpClient, HttpParams} from '@angular/common/http';
-import { catchError } from 'rxjs/operators';
-
-import { BasicService } from './basic.service';
-import { Settings } from '../models/settings.model';
-import {Languages} from '../enums/common.enum';
-
-@Injectable({
-  providedIn: 'root'
-})
-export class SettingsService extends BasicService {
-  defaultSettingsUrl = this.baseUrl + '/api/settings';
-
-  constructor(protected http: HttpClient) {
-    super(http);
-  }
-
-  /**
-   * Returns default application settings
-   * with sickday count and notification
-   */
-  getDefaultSettings() {
-    return this.makeGetSettingsApiCall(null);
-  }
-
-  /**
-   * Returns default application settings
-   * with sickday count and notification
-   * @param language filter by language
-   */
-  getDefaultSettingsWithLanguage(language: Languages) {
-    return this.makeGetSettingsApiCall(language);
-  }
-
-  /**
-   * Získání aktuálně použitého výchozího nastavení v aplikaci
-   * GET /setttings?[lang=<CZ,EN>]
-   * @param language filter with language
-   */
-  private makeGetSettingsApiCall(language: string) {
-    const httpParams: HttpParams = this.createParams({lang: language});
-    const options = {params: httpParams};
-
-    return this.http.get<Settings>(this.defaultSettingsUrl, options)
-      .pipe(
-        catchError(err => this.handleError(err))
-      );
-  }
-
-  postDefaultSettings(settings: Settings) {
-    return this.postDefaultSettingsWithOptions(settings, null);
-  }
-
-  postDefaultSettingsWithLanguage(settings: Settings, language: Languages) {
-    return this.postDefaultSettingsWithOptions(settings, language);
-  }
-
-  private postDefaultSettingsWithOptions(settings: Settings, language: Languages) {
-    const httpParams: HttpParams = this.createParams({lang: language});
-    const options = {params: httpParams};
-
-    return this.http.post<Settings>(this.defaultSettingsUrl, settings, options)
-      .pipe(
-        catchError(err => this.handleError(err))
-      );
-  }
-}

webapp/src/app/services/tests/settings.service.spec.ts

@@ +1 @@
+import {TestBed} from '@angular/core/testing';
+
+import {HttpClientTestingModule, HttpTestingController} from '@angular/common/http/testing';
+import {environment} from '../../../environments/environment';
+import {SettingsService} from '../api/settings.service';
+import {Languages} from '../../enums/common.enum';
+
+describe('SettingsService', () => {
+  let service: SettingsService;
+  let httpMock: HttpTestingController;
+  const baseUrl: string = environment.apiUrl;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [HttpClientTestingModule],
+      providers: [SettingsService]
+    });
+
+    service = TestBed.get(SettingsService);
+    httpMock = TestBed.get(HttpTestingController);
+  });
+  afterEach(() => httpMock.verify());
+
+  it('getDefaultSettings', () => {
+    const dummyData = {
+      sickdayCount: 3,
+      notification: '2019/05/25 14:41:31'
+    };
+
+    service.getDefaultSettings().subscribe((data: any) => {
+      expect(data.sickdayCount).toBeDefined();
+      expect(data.sickdayCount).toBe(3);
+      expect(data.notification).toBeDefined();
+    });
+
+    const req = httpMock.expectOne(baseUrl + '/api/settings');
+    expect(req.request.method).toBe('GET');
+    req.flush(dummyData);
+  });
+
+  it('getDefaultSettingsWithLanguage', () => {
+    const dummyData = {
+      sickdayCount: 3,
+      notification: '2019/05/25 14:41:31'
+    };
+
+    service.getDefaultSettingsWithLanguage(Languages.ENGLISH).subscribe((data: any) => {
+      expect(data.sickdayCount).toBeDefined();
+      expect(data.sickdayCount).toBe(3);
+      expect(data.notification).toBeDefined();
+    });
+
+    const req = httpMock.expectOne(baseUrl + '/api/settings?lang=EN');
+    expect(req.request.method).toBe('GET');
+    req.flush(dummyData);
+  });
+
+
+  it('postDefaultSettings', () => {
+    const dummyAnswer = {
+      answer: 'ok',
+    };
+
+    service.postDefaultSettings({sickdayCount: 3, notification: '2019/04/25 18:23:36'})
+      .subscribe((data: any) => expect(data.answer).toBe('ok'));
+
+    const req = httpMock.expectOne(baseUrl + '/api/settings');
+    expect(req.request.method).toBe('POST');
+    req.flush(dummyAnswer);
+  });
+
+  it('postDefaultSettingsWithLanguage', () => {
+    const dummyAnswer = {
+      answer: 'ok',
+    };
+
+    service.postDefaultSettingsWithLanguage({sickdayCount: 3, notification: '2019/04/25 18:23:36'}, Languages.ENGLISH)
+      .subscribe((data: any) => expect(data.answer).toBe('ok'));
+
+    const req = httpMock.expectOne(baseUrl + '/api/settings?lang=EN');
+    expect(req.request.method).toBe('POST');
+    req.flush(dummyAnswer);
+  });
+
+});

webapp/src/app/services/tests/user.service.spec.ts

@@ +1 @@
+import {TestBed} from '@angular/core/testing';
+
+import {UserService} from '../api/user.service';
+import {HttpClientTestingModule, HttpTestingController} from '@angular/common/http/testing';
+import {Languages, RequestStatus, UserType, VacationType} from '../../enums/common.enum';
+import {environment} from '../../../environments/environment';
+
+describe('UsersService', () => {
+  let service: UserService;
+  let httpMock: HttpTestingController;
+  const baseUrl: string = environment.apiUrl;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [HttpClientTestingModule],
+      providers: [UserService]
+    });
+
+    service = TestBed.get(UserService);
+    httpMock = TestBed.get(HttpTestingController);
+  });
+  afterEach(() => httpMock.verify());
+
+  it('getLoggedUser', () => {
+    const dummyData = {
+      id: 1,
+      firstName: 'Tomas',
+      lastName: 'Novak',
+      photo: 'https://st2.depositphotos.com/9223672/12056/v/950/depositphotos_120568236-stock-illustration-male-face-avatar-logo-template.jpg',
+      vacationCount: 8.5,
+      sickdayCount: 3,
+      status: 'ACCEPTED',
+      role: 'EMPLOYER',
+      notification: '2000/12/01 09:00:00'
+    };
+
+
+    service.getLoggedUserProfile().subscribe((data: any) => {
+      expect(data.id).toBe(1);
+      expect(data.vacationCount).toBe(8.5);
+      expect(data.sickdayCount).toBe(3);
+      expect(data.status).toBe(RequestStatus.ACCEPTED);
+      expect(data.role).toBe(UserType.EMPLOYER);
+      expect(data.notification).toBeDefined();
+    });
+
+    const req = httpMock.expectOne(baseUrl + '/api/user/me/profile');
+    expect(req.request.method).toBe('GET');
+    req.flush(dummyData);
+  });
+
+  it('getLoggedUserWithLanguage', () => {
+    const dummyData = {
+      id: 1,
+      firstName: 'Tomas',
+      lastName: 'Novak',
+      photo: 'https://st2.depositphotos.com/9223672/12056/v/950/depositphotos_120568236-stock-illustration-male-face-avatar-logo-template.jpg',
+      vacationCount: 8.5,
+      sickdayCount: 3,
+      status: 'ACCEPTED',
+      role: 'EMPLOYER',
+      notification: '2000/12/01 09:00:00'
+    };
+
+
+    service.getLoggedUserProfileWithLanguage(Languages.ENGLISH).subscribe((data: any) => {
+      expect(data.id).toBe(1);
+      expect(data.vacationCount).toBe(8.5);
+      expect(data.sickdayCount).toBe(3);
+      expect(data.status).toBe(RequestStatus.ACCEPTED);
+      expect(data.role).toBe(UserType.EMPLOYER);
+      expect(data.notification).toBeDefined();
+    });
+
+    const req = httpMock.expectOne(baseUrl + '/api/user/me/profile?lang=EN');
+    expect(req.request.method).toBe('GET');
+    req.flush(dummyData);
+  });
+
+  it('getLoggedUserCalendar', () => {
+    const dummyData = [
+      {id: 1, date: '2000/10/10', from: '09:00', to: '13:00', type: 'VACATION'},
+      {id: 2, date: '2000/10/11', type: 'SICKDAY'},
+      {id: 3, date: '2000/10/12', from: '09:00', to: '13:00', type: 'VACATION'},
+      {id: 4, date: '2000/10/13', type: 'SICKDAY'},
+      {id: 5, date: '2000/10/14', from: '09:00', to: '13:00', type: 'VACATION'}
+    ];
+
+    service.getLoggedUserCalendar(new Date(1995, 10, 25))
+      .subscribe((data: any) => {
+        expect(data.length).toBe(5);
+        expect(data[1].type).toBe(VacationType.SICKDAY);
+        expect(data[2].type).toBe(VacationType.VACATION);
+        expect(data[2].from).toBeDefined();
+        expect(data[2].to).toBeDefined();
+      });
+
+    const req = httpMock.expectOne(baseUrl + '/api/user/me/calendar?from=1995/10/25');
+    expect(req.request.method).toBe('GET');
+    req.flush(dummyData);
+  });
+
+  it('getLoggedUserCalendarWithOptions', () => {
+    const dummyData = [
+      {id: 1, date: '2000/10/10', from: '09:00', to: '13:00', type: 'VACATION', status: 'ACCEPTED'},
+      {id: 2, date: '2000/10/11', type: 'SICKDAY', status: 'ACCEPTED'},
+      {id: 3, date: '2000/10/12', from: '09:00', to: '13:00', type: 'VACATION', status: 'ACCEPTED'},
+      {id: 4, date: '2000/10/13', type: 'SICKDAY', status: 'ACCEPTED'},
+      {id: 5, date: '2000/10/14', from: '09:00', to: '13:00', type: 'VACATION', status: 'ACCEPTED'}
+    ];
+
+    service.getLoggedUserCalendarWithOptions(new Date(1995, 10, 25), null, null, RequestStatus.ACCEPTED)
+      .subscribe((data: any) => {
+        expect(data.length).toBe(5);
+        expect(data[0].status).toBeDefined();
+        expect(data[0].status).toBe(RequestStatus.ACCEPTED);
+        expect(data[1].status).toBe(RequestStatus.ACCEPTED);
+        expect(data[2].status).toBe(RequestStatus.ACCEPTED);
+        expect(data[3].status).toBe(RequestStatus.ACCEPTED);
+        expect(data[4].status).toBe(RequestStatus.ACCEPTED);
+      });
+
+    const req = httpMock.expectOne(baseUrl + '/api/user/me/calendar?from=1995/10/25&status=ACCEPTED');
+    expect(req.request.method).toBe('GET');
+    req.flush(dummyData);
+  });
+});

webapp/src/app/services/tests/users.service.spec.ts

@@ +1 @@
+import {TestBed} from '@angular/core/testing';
+
+import {UsersService} from '../api/users.service';
+import {HttpClientTestingModule, HttpTestingController} from '@angular/common/http/testing';
+import {RequestStatus, VacationType} from '../../enums/common.enum';
+import {environment} from '../../../environments/environment';
+
+describe('UsersService', () => {
+  let service: UsersService;
+  let httpMock: HttpTestingController;
+  const baseUrl: string = environment.apiUrl;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [HttpClientTestingModule],
+      providers: [UsersService]
+    });
+
+    service = TestBed.get(UsersService);
+    httpMock = TestBed.get(HttpTestingController);
+  });
+  afterEach(() => httpMock.verify());
+
+
+  it('getAuthorizationRequests', () => {
+    const dummyRequests = [
+      { id: 1, firstName: 'Tomas', lastName: 'Novak', timestamp: '2019/05/24 21:55:11' },
+      { id: 2, firstName: 'Tomas', lastName: 'Novak', timestamp: '2019/05/24 21:55:11' },
+      { id: 3, firstName: 'Tomas', lastName: 'Novak', timestamp: '2019/05/24 21:55:11' },
+      { id: 4, firstName: 'Tomas', lastName: 'Novak', timestamp: '2019/05/24 21:55:11' },
+      { id: 5, firstName: 'Tomas', lastName: 'Novak', timestamp: '2019/05/24 21:55:11' }
+    ];
+
+    service.getAuthorizationRequests().subscribe((data: any) => {
+      expect(data.length).toBe(5);
+      expect(data[4].lastName).toBe('Novak');
+      expect(data[4].firstName).toBe('Tomas');
+      expect(data[4].id).toBe(5);
+      expect(data[4].timestamp).toBeDefined();
+    });
+
+    const req = httpMock.expectOne(baseUrl + '/api/users/requests/authorization');
+    expect(req.request.method).toBe('GET');
+    req.flush(dummyRequests);
+  });
+
+  it('getVacationRequests', () => {
+    const dummyRequests = [
+        {id: 1, firstName: 'Tomas', lastName: 'Novak', date: '2019/05/24', type: 'SICKDAY', timestamp: '2019/05/24 21:59:32'},
+        { id: 2, firstName: 'Tomas', lastName: 'Novak', date: '2019/05/24', from: '09:30', to: '18:30', type: 'VACATION', timestamp: '2019/05/24 21:59:32' },
+        {id: 3, firstName: 'Tomas', lastName: 'Novak', date: '2019/05/24', type: 'SICKDAY', timestamp: '2019/05/24 21:59:32'},
+        { id: 4, firstName: 'Tomas', lastName: 'Novak', date: '2019/05/24', from: '09:30', to: '18:30', type: 'VACATION', timestamp: '2019/05/24 21:59:32' },
+        {id: 5, firstName: 'Tomas', lastName: 'Novak', date: '2019/05/24', type: 'SICKDAY', timestamp: '2019/05/24 21:59:32'}
+      ];
+    service.getVacationRequests().subscribe((data: any) => {
+      expect(data.length).toBe(5);
+
+      expect(data[0].firstName).toBeDefined();
+      expect(data[0].lastName).toBeDefined();
+
+      expect(data[0].type).toBe(VacationType.SICKDAY);
+      expect(data[0].to).toBeUndefined();
+      expect(data[0].from).toBeUndefined();
+
+      expect(data[1].type).toBe(VacationType.VACATION);
+      expect(data[1].to).toBeDefined();
+      expect(data[1].from).toBeDefined();
+    });
+
+    const req = httpMock.expectOne(baseUrl + '/api/users/requests/vacation');
+    expect(req.request.method).toBe('GET');
+    req.flush(dummyRequests);
+  });
+
+
+  it('getAllUsers', () => {
+    const dummyRequests = [
+      {
+        id: 1,
+        firstName: 'Tomas',
+        lastName: 'unknown',
+        photo: 'https://st2.depositphotos.com/9223672/12056/v/950/depositphotos_120568236-stock-illustration-male-face-avatar-logo-template.jpg',
+        calendar: [
+          {
+            id: 1,
+            date: '2019/05/24',
+            from: '09:00',
+            to: '13:00',
+            type: 'VACATION',
+            status: 'ACCEPTED'
+          },
+          {
+            id: 2,
+            date: '2019/05/25',
+            from: '09:00',
+            to: '13:00',
+            type: 'VACATION',
+            status: 'ACCEPTED'
+          }
+        ]
+      },
+      {
+        id: 2,
+        firstName: 'Tomas',
+        lastName: 'unknown',
+        photo: 'https://st2.depositphotos.com/9223672/12056/v/950/depositphotos_120568236-stock-illustration-male-face-avatar-logo-template.jpg',
+        calendar: [
+          {
+            id: 1,
+            date: '2019/05/24',
+            from: '09:00',
+            to: '13:00',
+            type: 'VACATION',
+            status: 'ACCEPTED'
+          },
+          {
+            id: 2,
+            date: '2019/05/25',
+            from: '09:00',
+            to: '13:00',
+            type: 'VACATION',
+            status: 'ACCEPTED'
+          }
+        ]
+      },
+      {
+        id: 3,
+        firstName: 'Tomas',
+        lastName: 'unknown',
+        photo: 'https://st2.depositphotos.com/9223672/12056/v/950/depositphotos_120568236-stock-illustration-male-face-avatar-logo-template.jpg',
+        calendar: [
+          {
+            id: 1,
+            date: '2019/05/24',
+            from: '09:00',
+            to: '13:00',
+            type: 'VACATION',
+            status: 'ACCEPTED'
+          },
+          {
+            id: 2,
+            date: '2019/05/25',
+            from: '09:00',
+            to: '13:00',
+            type: 'VACATION',
+            status: 'ACCEPTED'
+          }
+        ]
+      },
+      {
+        id: 4,
+        firstName: 'Tomas',
+        lastName: 'unknown',
+        photo: 'https://st2.depositphotos.com/9223672/12056/v/950/depositphotos_120568236-stock-illustration-male-face-avatar-logo-template.jpg',
+        calendar: [
+          {
+            id: 1,
+            date: '2019/05/24',
+            from: '09:00',
+            to: '13:00',
+            type: 'VACATION',
+            status: 'ACCEPTED'
+          },
+          {
+            id: 2,
+            date: '2019/05/25',
+            from: '09:00',
+            to: '13:00',
+            type: 'VACATION',
+            status: 'ACCEPTED'
+          }
+        ]
+      },
+      {
+        id: 5,
+        firstName: 'Tomas',
+        lastName: 'unknown',
+        photo: 'https://st2.depositphotos.com/9223672/12056/v/950/depositphotos_120568236-stock-illustration-male-face-avatar-logo-template.jpg',
+        calendar: [
+          {
+            id: 1,
+            date: '2019/05/24',
+            from: '09:00',
+            to: '13:00',
+            type: 'VACATION',
+            status: 'ACCEPTED'
+          },
+          {
+            id: 2,
+            date: '2019/05/25',
+            from: '09:00',
+            to: '13:00',
+            type: 'VACATION',
+            status: 'ACCEPTED'
+          }
+        ]
+      }
+    ];
+    service.getUsers().subscribe((data: any) => {
+      expect(data.length).toBe(5);
+      expect(data[0].id).toBe(1);
+      expect(data[0].firstName).toBeDefined();
+      expect(data[0].lastName).toBeDefined();
+      expect(data[0].photo).toBeDefined();
+      expect(data[0].calendar[0].type).toBe(VacationType.VACATION);
+      expect(data[0].calendar[0].status).toBe(RequestStatus.ACCEPTED);
+      expect(data[0].calendar[0].id).toBe(1);
+      expect(data[0].calendar[1].id).toBe(2);
+    });
+
+    const req = httpMock.expectOne(baseUrl + '/api/users');
+    expect(req.request.method).toBe('GET');
+    req.flush(dummyRequests);
+  });
+
+});

webapp/src/app/services/user.service.spec.ts

@@ -1 @@
-import {TestBed} from '@angular/core/testing';
-
-import {UserService} from './user.service';
-import {HttpClientTestingModule, HttpTestingController} from '@angular/common/http/testing';
-import {Languages, RequestStatus, UserType, VacationType} from '../enums/common.enum';
-import {environment} from '../../environments/environment';
-
-describe('UsersService', () => {
-  let service: UserService;
-  let httpMock: HttpTestingController;
-  const baseUrl: string = environment.apiUrl;
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      imports: [HttpClientTestingModule],
-      providers: [UserService]
-    });
-
-    service = TestBed.get(UserService);
-    httpMock = TestBed.get(HttpTestingController);
-  });
-  afterEach(() => httpMock.verify());
-
-  it('getLoggedUser', () => {
-    const dummyData = {
-      id: 1,
-      firstName: 'Tomas',
-      lastName: 'Novak',
-      photo: 'https://st2.depositphotos.com/9223672/12056/v/950/depositphotos_120568236-stock-illustration-male-face-avatar-logo-template.jpg',
-      vacationCount: 8.5,
-      sickdayCount: 3,
-      status: 'ACCEPTED',
-      role: 'EMPLOYER',
-      notification: '2000/12/01 09:00:00'
-    };
-
-