Исправлена работа с пользователями

libs/event-emitter/src/models/redmine-types.ts

@@ -81,7 +81,7 @@ export module RedmineTypes {
 
     export const user: User = {
       id: num,
-      login: unknownName,
+      login: str,
       firstname: unknownName,
       lastname: unknownName,
       mail: str,
@@ -96,11 +96,28 @@ export module RedmineTypes {
     mail: string;
   };
 
-  export function ExtractUser(obj: User): User & { name: string } {
+  export type PublicUser = {
+    id: number;
+    firstname: string;
+    lastname: string;
+    login: string;
+    name: string;
+  };
+
+  export function CreatePublicUserFromUser(obj: User): PublicUser {
     return {
       id: obj.id,
       login: obj.login,
+      firstname: obj.firstname,
+      lastname: obj.lastname,
       name: `${obj.firstname} ${obj.lastname}`,
+    };
+  }
+
+  export function CreateUser(obj: User): User {
+    return {
+      id: obj.id,
+      login: obj.login,
       firstname: obj.firstname,
       lastname: obj.lastname,
       mail: obj.mail,

libs/event-emitter/src/redmine-data-loader/redmine-data-loader.ts

@@ -55,7 +55,7 @@ export class RedmineDataLoader {
     this.logger.debug(
       `Loaded user, userNumber = ${userNumber}, login = ${user.login}, firstname = ${user.firstname}, lastname = ${user.lastname}`,
     );
-    return RedmineTypes.ExtractUser(user);
+    return RedmineTypes.CreateUser(user);
   }
 
   private getIssueUrl(issueNumber: number): string {

libs/event-emitter/src/users/users.controller.ts

@@ -7,14 +7,14 @@ export class UsersController {
   constructor(private readonly usersService: UsersService) {}
 
   @Get(':id')
-  async getUser(@Param('id') id: number): Promise<RedmineTypes.User> {
+  async getUser(@Param('id') id: number): Promise<RedmineTypes.PublicUser> {
     return await this.usersService.getUser(id);
   }
 
   @Get(':id/json')
   async getUserLikeRedmine(
     @Param('id') id: number,
-  ): Promise<{ user: RedmineTypes.User }> {
+  ): Promise<{ user: RedmineTypes.PublicUser }> {
     const user = await this.usersService.getUser(id);
     return {
       user: user,

libs/event-emitter/src/users/users.service.ts

@@ -1,5 +1,4 @@
 import { Injectable, Logger } from '@nestjs/common';
-import { Timestamped } from '../models/timestamped';
 import { Users } from '../couchdb-datasources/users';
 import { RedmineDataLoader } from '../redmine-data-loader/redmine-data-loader';
 import { RedmineUserCacheWriterService } from '../user-cache-writer/user-cache-writer.service';
@@ -23,15 +22,15 @@ export class UsersService {
     private redmineUserCacheWriterService: RedmineUserCacheWriterService,
   ) {}
 
-  async getUser(userId: number): Promise<RedmineTypes.User> {
+  async getUser(userId: number): Promise<RedmineTypes.PublicUser> {
     const userFromMemoryCache = this.getUserFromMemoryCache(userId);
     if (userFromMemoryCache) {
-      return userFromMemoryCache;
+      return RedmineTypes.CreatePublicUserFromUser(userFromMemoryCache);
     }
     const userFromCache = await this.getUserFromCache(userId);
     if (userFromCache) {
       this.memoryCache.set(userId, userFromCache);
-      return userFromCache;
+      return RedmineTypes.CreatePublicUserFromUser(userFromCache);
     }
     let userFromRedmine = await this.getUserFromRedmine(userId);
     if (userFromRedmine) {
@@ -39,13 +38,17 @@ export class UsersService {
         userFromRedmine,
       );
     }
-    return this.memoryCache.set(
+    return RedmineTypes.CreatePublicUserFromUser(
-      userId,
+      this.memoryCache.set(
-      userFromRedmine || RedmineTypes.Unknown.user,
+        userId,
+        userFromRedmine || RedmineTypes.Unknown.user,
+      ),
     );
   }
 
-  async getUserFromRedmine(userId: number): Promise<RedmineTypes.User | null> {
+  private async getUserFromRedmine(
+    userId: number,
+  ): Promise<RedmineTypes.User | null> {
     const user = await this.redmineDataLoader.loadUser(userId);
     if (user) {
       this.logger.debug(
@@ -55,9 +58,9 @@ export class UsersService {
     return user;
   }
 
-  async getUserFromCache(
+  private async getUserFromCache(
     userId: number,
-  ): Promise<(RedmineTypes.User & Timestamped) | null> {
+  ): Promise<RedmineTypes.User | null> {
     const usersDb = await this.users.getDatasource();
     try {
       const user = (await usersDb.get(String(userId))) as any;
@@ -70,7 +73,7 @@ export class UsersService {
     }
   }
 
-  getUserFromMemoryCache(userId: number): RedmineTypes.User | null {
+  private getUserFromMemoryCache(userId: number): RedmineTypes.User | null {
     const user = this.memoryCache.get(userId);
     if (user) {
       this.logger.debug(