Yakymiv/officials list

src/app/shared/components/users-list/users-list.component.html

@@ -24,6 +24,14 @@
         </td>
       </ng-container>
 
+      <!-- Rnokpp Column -->
+      <ng-container matColumnDef="rnokpp">
+        <th mat-header-cell *matHeaderCellDef mat-sort-header sortActionDescription="Sort by RNOKPP">
+          {{ 'FORMS.LABELS.RNOKPP' | translate }}
+        </th>
+        <td mat-cell *matCellDef="let element" class="tab">{{ element.rnokpp }}</td>
+      </ng-container>
+
       <!-- Email Column -->
       <ng-container matColumnDef="email">
         <th mat-header-cell *matHeaderCellDef mat-sort-header sortActionDescription="Sort by email">

src/app/shared/models/employee.model.ts

@@ -4,6 +4,7 @@ import { Person } from './user.model';
 
 export interface EmployeeParameters extends PaginationParameters {
   searchString?: string;
+  providerId?: string;
 }
 
 export class Employee implements Person {

src/app/shared/models/official-employee.model.ts

@@ -0,0 +1,20 @@
+import { Person } from './user.model';
+
+export class OfficialEmployee implements Person {
+  id?: string;
+  userId?: string;
+  position: string;
+  positionId: string;
+  firstName: string;
+  middleName?: string;
+  lastName: string;
+  rnokpp: string;
+  // TODO: add this functionality when avaliable on backend
+  dismissalOrder: string;
+  recruitmentOrder: string;
+  dismissalReason: string;
+  employmentType: string;
+  //
+  activeFrom: string;
+  activeTo: string;
+}

src/app/shared/models/users-table.ts

@@ -48,3 +48,10 @@ export interface InvitationData {
   user: AdminsTableData;
   adminType: AdminRoles;
 }
+
+export interface OfficialEmployeeTableData {
+  id: string;
+  pib: string;
+  role: string;
+  rnokpp: string;
+}

src/app/shared/services/employee/employee.service.spec.ts

@@ -1,20 +1,159 @@
-import { HttpClientTestingModule } from '@angular/common/http/testing';
+import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing';
 import { TestBed } from '@angular/core/testing';
 import { NgxsModule } from '@ngxs/store';
-
+import { Employee, EmployeeParameters } from 'shared/models/employee.model';
+import { SearchResponse } from 'shared/models/search.model';
+import { OfficialEmployee } from 'shared/models/official-employee.model';
+import { EmployeeBlockData } from 'shared/models/block.model';
 import { EmployeeService } from './employee.service';
 
 describe('EmployeeService', () => {
   let service: EmployeeService;
+  let httpMock: HttpTestingController;
 
   beforeEach(() => {
     TestBed.configureTestingModule({
-      imports: [HttpClientTestingModule, NgxsModule.forRoot([])]
+      imports: [HttpClientTestingModule, NgxsModule.forRoot([])],
+      providers: [EmployeeService]
     });
     service = TestBed.inject(EmployeeService);
+    httpMock = TestBed.inject(HttpTestingController);
+  });
+
+  afterEach(() => {
+    httpMock.verify();
   });
 
   it('should be created', () => {
     expect(service).toBeTruthy();
   });
+
+  it('should GET employee by id', () => {
+    const mockEmployee: Employee = { id: '1', firstName: 'John', lastName: 'Smith', email: 'email', phoneNumber: 'number' };
+    const employeeId = '1';
+
+    service.getEmployeeById(employeeId).subscribe((employee) => {
+      expect(employee).toEqual(mockEmployee);
+    });
+
+    const req = httpMock.expectOne(`/api/v1/Employees/GetEmployeeById/${employeeId}`);
+    expect(req.request.method).toBe('GET');
+
+    req.flush(mockEmployee);
+  });
+
+  it('should GET filtered official employees', () => {
+    const filterParams: EmployeeParameters = {
+      searchString: 'John',
+      from: 0,
+      size: 10,
+      providerId: '1'
+    };
+
+    const mockResponse: SearchResponse<OfficialEmployee[]> = {
+      entities: [
+        {
+          id: '1',
+          firstName: 'John',
+          lastName: 'Doe',
+          position: 'employee',
+          positionId: '1',
+          rnokpp: '111',
+          dismissalOrder: '',
+          recruitmentOrder: '',
+          dismissalReason: '',
+          employmentType: '',
+          activeFrom: '',
+          activeTo: ''
+        }
+      ],
+      totalAmount: 1
+    };
+
+    service.getFilteredOfficialEmployees(filterParams).subscribe((response) => {
+      expect(response).toEqual(mockResponse);
+    });
+
+    const req = httpMock.expectOne(`/api/v1/providers/${filterParams.providerId}/officials/Get?searchString=John&from=0&size=10`);
+    expect(req.request.method).toBe('GET');
+
+    req.flush(mockResponse);
+  });
+
+  it('should create a new employee', () => {
+    const newEmployee: Employee = { id: '1', firstName: 'John', lastName: 'Smith', email: 'email', phoneNumber: '+000' };
+
+    service.createEmployee(newEmployee).subscribe((response) => {
+      expect(response).toEqual(newEmployee);
+    });
+
+    const req = httpMock.expectOne('/api/v1/Employees/Create');
+    expect(req.request.method).toBe('POST');
+    expect(req.request.body).toEqual(newEmployee);
+
+    req.flush(newEmployee);
+  });
+
+  it('should DELETE an employee', () => {
+    const employeeId = '1';
+    const providerId = '1';
+
+    service.deleteEmployee(employeeId, providerId).subscribe((response) => {
+      expect(response).toBeUndefined();
+    });
+
+    const req = httpMock.expectOne(`/api/v1/Employees/Delete?employeeId=${employeeId}&providerId=${providerId}`);
+    expect(req.request.method).toBe('DELETE');
+
+    req.flush(null);
+  });
+
+  it('should block an employee successfully', () => {
+    const employeeBlockParams: EmployeeBlockData = {
+      userId: '1',
+      providerId: '1',
+      isBlocked: true
+    };
+
+    service.blockEmployee(employeeBlockParams).subscribe((response) => {
+      expect(response).toBeUndefined();
+    });
+
+    const req = httpMock.expectOne(
+      `/api/v1/Employees/Block?employeeId=${employeeBlockParams.userId}&providerId=${employeeBlockParams.providerId}&isBlocked=true`
+    );
+    expect(req.request.method).toBe('PUT');
+    expect(req.request.body).toEqual({});
+
+    req.flush(null);
+  });
+
+  it('should update an employee successfully', () => {
+    const providerId = '1';
+    const updatedEmployee: Employee = { id: '1', firstName: 'John', lastName: 'Smith', email: 'email', phoneNumber: 'number' };
+
+    service.updateEmployee(providerId, updatedEmployee).subscribe((response) => {
+      expect(response).toEqual(updatedEmployee);
+    });
+
+    const req = httpMock.expectOne(`/api/v1/Employees/Update?providerId=${providerId}`);
+    expect(req.request.method).toBe('PUT');
+    expect(req.request.body).toEqual(updatedEmployee);
+
+    req.flush(updatedEmployee);
+  });
+
+  it('should reinvite an employee successfully', () => {
+    const employee: Employee = { id: '1', firstName: 'John', lastName: 'Smith', email: 'email', phoneNumber: 'number' };
+
+    service.reinvateEmployee(employee).subscribe((response) => {
+      expect(response).toBeUndefined();
+    });
+
+    const req = httpMock.expectOne(`/api/v1/Employees/Reinvite/${employee.id}`);
+    expect(req.request.method).toBe('PUT');
+    expect(req.request.body).toEqual(employee);
+
+    req.flush(null);
+  });
 });

src/app/shared/services/employee/employee.service.ts

@@ -4,6 +4,7 @@ import { Observable } from 'rxjs';
 
 import { EmployeeBlockData } from 'shared/models/block.model';
 import { Employee, EmployeeParameters } from 'shared/models/employee.model';
+import { OfficialEmployee } from 'shared/models/official-employee.model';
 import { SearchResponse } from 'shared/models/search.model';
 
 @Injectable({
@@ -23,13 +24,13 @@ export class EmployeeService {
   /**
    * This method get provider admisn with filter parameters
    */
-  public getFilteredEmployees(filterParams: EmployeeParameters): Observable<SearchResponse<Employee[]>> {
+  public getFilteredOfficialEmployees(filterParams: EmployeeParameters): Observable<SearchResponse<OfficialEmployee[]>> {
     const params = new HttpParams()
       .set('searchString', `${filterParams.searchString}`)
       .set('from', `${filterParams.from}`)
       .set('size', `${filterParams.size}`);
 
-    return this.http.get<SearchResponse<Employee[]>>('/api/v1/Employees/GetFilteredEmployees', {
+    return this.http.get<SearchResponse<OfficialEmployee[]>>(`/api/v1/providers/${filterParams.providerId}/officials/Get`, {
       params
     });
   }

src/app/shared/store/provider.actions.ts

@@ -79,8 +79,8 @@ export class GetProviderViewWorkshops {
   constructor(public workshopCardParameters: WorkshopCardParameters) {}
 }
 
-export class GetFilteredEmployees {
-  static readonly type = '[provider] get filtered Employee users';
+export class GetFilteredOfficialEmployees {
+  static readonly type = '[provider] get filtered Official Employee users';
   constructor(public payload: EmployeeParameters) {}
 }
 

src/app/shared/store/provider.state.ts

@@ -14,6 +14,7 @@ import { BlockedParent } from 'shared/models/block.model';
 import { Child } from 'shared/models/child.model';
 import { TruncatedItem } from 'shared/models/item.model';
 import { Employee } from 'shared/models/employee.model';
+import { OfficialEmployee } from 'shared/models/official-employee.model';
 import { Provider, ProviderWithLicenseStatus, ProviderWithStatus } from 'shared/models/provider.model';
 import { SearchResponse } from 'shared/models/search.model';
 import { Workshop, WorkshopProviderViewCard, WorkshopStatus } from 'shared/models/workshop.model';
@@ -37,7 +38,7 @@ export interface ProviderStateModel {
   selectedAchievement: Achievement;
   approvedChildren: SearchResponse<Child[]>;
   providerWorkshops: SearchResponse<WorkshopProviderViewCard[]>;
-  employees: SearchResponse<Employee[]>;
+  officialEmployees: SearchResponse<OfficialEmployee[]>;
   selectedEmployee: Employee;
   blockedParent: BlockedParent;
   truncatedItems: TruncatedItem[];
@@ -54,7 +55,7 @@ export interface ProviderStateModel {
     achievements: null,
     selectedAchievement: null,
     providerWorkshops: null,
-    employees: null,
+    officialEmployees: null,
     selectedEmployee: null,
     blockedParent: null,
     truncatedItems: null,
@@ -102,8 +103,8 @@ export class ProviderState {
   }
 
   @Selector()
-  static employees(state: ProviderStateModel): SearchResponse<Employee[]> {
-    return state.employees;
+  static officialEmployees(state: ProviderStateModel): SearchResponse<OfficialEmployee[]> {
+    return state.officialEmployees;
   }
 
   @Selector()
@@ -322,15 +323,19 @@ export class ProviderState {
       );
   }
 
-  @Action(providerActions.GetFilteredEmployees)
-  getFilteredEmployees(
+  @Action(providerActions.GetFilteredOfficialEmployees)
+  getFilteredOfficialEmployees(
     { patchState }: StateContext<ProviderStateModel>,
-    { payload }: providerActions.GetFilteredEmployees
-  ): Observable<SearchResponse<Employee[]>> {
+    { payload }: providerActions.GetFilteredOfficialEmployees
+  ): Observable<SearchResponse<OfficialEmployee[]>> {
     patchState({ isLoading: true });
     return this.employeeService
-      .getFilteredEmployees(payload)
-      .pipe(tap((employees: SearchResponse<Employee[]>) => patchState({ employees: employees ?? EMPTY_RESULT, isLoading: false })));
+      .getFilteredOfficialEmployees(payload)
+      .pipe(
+        tap((officials: SearchResponse<OfficialEmployee[]>) =>
+          patchState({ officialEmployees: officials ?? EMPTY_RESULT, isLoading: false })
+        )
+      );
   }
 
   @Action(providerActions.CreateWorkshop)
@@ -595,7 +600,7 @@ export class ProviderState {
     { payload, filterParams }: providerActions.OnBlockEmployeeSuccess
   ): void {
     dispatch([
-      new providerActions.GetFilteredEmployees(filterParams),
+      new providerActions.GetFilteredOfficialEmployees(filterParams),
       new ShowMessageBar({
         message: payload.isBlocked ? SnackbarText.blockPerson : SnackbarText.unblockPerson,
         type: 'success'
@@ -622,7 +627,7 @@ export class ProviderState {
   @Action(providerActions.OnDeleteEmployeeSuccess)
   onDeleteEmployeeSuccess({ dispatch }: StateContext<ProviderStateModel>, { filterParams }: providerActions.OnDeleteEmployeeSuccess): void {
     dispatch([
-      new providerActions.GetFilteredEmployees(filterParams),
+      new providerActions.GetFilteredOfficialEmployees(filterParams),
       new ShowMessageBar({
         message: SnackbarText.deleteEmployee,
         type: 'success'

src/app/shared/utils/utils.ts

@@ -2,7 +2,6 @@ import { KeyValue } from '@angular/common';
 
 import { CodeMessageErrors } from 'shared/enum/enumUA/errors';
 import { Localization } from 'shared/enum/enumUA/localization';
-import { EmployeeTitles } from 'shared/enum/enumUA/employee';
 import { UserTabsTitles } from 'shared/enum/enumUA/user';
 import { NotificationDescriptionType, NotificationType } from 'shared/enum/notifications';
 import { EmailConfirmationStatuses, UserStatuses } from 'shared/enum/statuses';
@@ -15,13 +14,13 @@ import { MessageBarData } from 'shared/models/message-bar.model';
 import { MinistryAdmin } from 'shared/models/ministry-admin.model';
 import { Notification } from 'shared/models/notification.model';
 import { PaginationElement } from 'shared/models/pagination-element.model';
-import { Employee } from 'shared/models/employee.model';
 import { PaginationParameters } from 'shared/models/query-parameters.model';
 import { Person } from 'shared/models/user.model';
-import { AdminsTableData, EmployeesTableData, UsersTableData } from 'shared/models/users-table';
+import { AdminsTableData, OfficialEmployeeTableData, UsersTableData } from 'shared/models/users-table';
 import { Workshop } from 'shared/models/workshop.model';
 import { ValidationConstants } from 'shared/constants/validation';
 import { TIME_REGEX_REPLACE } from 'shared/constants/regex-constants';
+import { OfficialEmployee } from 'shared/models/official-employee.model';
 
 /**
  * Utility class that providers methods for shared data manipulations
@@ -138,23 +137,21 @@ export class Util {
   }
 
   /**
-   * This method returns updated array structure for the Employee table
-   * @param admins Employee[]
+   * This method returns updated array structure for the Official Employees table
+   * @param admins OfficialEmployee[]
    * @returns array of objects
    */
-  public static updateStructureForTheTableEmployees(admins: Employee[]): EmployeesTableData[] {
-    const updatedEmployees = [];
-    admins.forEach((admin: Employee) => {
-      updatedEmployees.push({
+  public static updateStructureForTheTableOfficialEmployees(admins: OfficialEmployee[]): OfficialEmployeeTableData[] {
+    const updatedOfficialEmployees: OfficialEmployeeTableData[] = [];
+    admins.forEach((admin: OfficialEmployee) => {
+      updatedOfficialEmployees.push({
         id: admin.id,
         pib: `${admin.lastName} ${admin.firstName} ${admin.middleName}`,
-        email: admin.email,
-        phoneNumber: `${admin.phoneNumber}`,
-        role: EmployeeTitles.Admin,
-        status: admin.accountStatus
+        role: admin.position,
+        rnokpp: admin.rnokpp
       });
     });
-    return updatedEmployees;
+    return updatedOfficialEmployees;
   }
 
   /**