Messenger. Технический обзор сервера (Nest.js)

async searchUsers(query: string, page: number, pageSize: number) {
    const offset = (page - 1) * pageSize;
    const lowercaseQuery = `%${query.toLowerCase()}%`;
    const queryWithPagination = await this.userRepository.findAndCountAll({
      where: {
        isDeleted: false,
        [Op.or]: [
          Sequelize.where(Sequelize.fn('LOWER', Sequelize.col('userName')), {
            [Op.like]: lowercaseQuery,
          }),
          Sequelize.where(Sequelize.fn('LOWER', Sequelize.col('profile.firstName')), {
            [Op.like]: lowercaseQuery,
          }),
          Sequelize.where(Sequelize.fn('LOWER', Sequelize.col('profile.lastName')), {
            [Op.like]: lowercaseQuery,
          }),
        ],
      },
      include: [{
        model: Profile,
        required: false,
      }],
      limit: pageSize,
      offset,
      attributes: [
        'id',
        'userName',
        'banned',
        'banReason',
        'avatar',
        'isDeleted',
        'createdAt',
      ],
      distinct: true,
    });
    const totalPages = Math.ceil(queryWithPagination.count / pageSize); 
    return {
      users: queryWithPagination.rows,
      page,
      pageSize,
      totalPages,
      totalUsers: queryWithPagination.count,
    }
  }

async setAvatar(
    userId: number, 
    image: any, 
    cropWidth: number, 
    cropHeight: number, 
    cropLeft: number, 
    cropTop: number
  ) {
  const imageType = 'webp';
  const fileName = uuid.v4();
  const dbAvatarName = fileName + '.' + imageType;
  await this.fileService.setAvatar('avatar', image, cropWidth, cropHeight, cropLeft, cropTop, imageType, fileName);

  const user = await this.userRepository.findOne({ where: { 
    id: userId, 
    banned: false, 
    isDeleted: false 
  }});

  await this.fileService.deleteAvatar('avatar', user.avatar);
  user.avatar = dbAvatarName;
  await user.save();

  if(user.avatar === dbAvatarName) {
    return { fileName: fileName + '.' + imageType };
  }  else throw new HttpException('Set avatar error', HttpStatus.INTERNAL_SERVER_ERROR);
}

@Module({
  controllers: [ProfileController],
  providers: [ProfileService],
  imports: [
    SequelizeModule.forFeature([Profile, User]),
],
  exports: [ProfileService],
})
export class ProfileModule {}

async getProfile(userId: number) {
    return await this.profileRepository.findByPk(userId, { 
      include: [
        { model: User, as: 'user', attributes: ['userName', 'avatar', 'lastSeen'],
        include: [
          { model: Role, as: 'roles' }
        ]
      }
      ]
    });
  }

async editProfile(dto: EditProfileDto): Promise<any> {
        const updateData = {
          firstName: dto.firstName,
          lastName: dto.lastName,
          about: dto.about,
          birthday: dto.birthday,
          sex: dto.sex,
          country: dto.country,
          city: dto.city,
        };

      const updateFields = Object.fromEntries(Object.entries(updateData).filter(([, value]) => value !== undefined));
      const updatedProfile = await this.profileRepository.update(updateFields, { where: { userId: dto.userId } });
      return { status: updatedProfile[0] ? true : false };
  }

@Module({
  imports: [
    forwardRef(() => UsersModule),
    JwtModule.register({}),
    TokensModule,
  ],
    
  controllers: [AuthController],
  providers: [AuthService, AccessTokenStrategy, RefreshTokenStrategy],
  exports: [
    AuthService,
    JwtModule
]
})
export class AuthModule {}

async login(userName: string, password: string, sessionId: number, userIp: string, userAgent: string): Promise<any> {
    const user = await this.usersService.getUserByNameAdmin(userName);
    if (!user) throw new ForbiddenException('Неверный логин');
    const passwordMatches = await argon2.verify(user.password, password);
    if (!passwordMatches)
      throw new BadRequestException('Неверный пароль');
    if(user.banned) throw new BadRequestException('Пользователь забанен: ' + user.banReason);
    if(user.isDeleted) throw new BadRequestException('Пользователь удален');
    const tokens = await this.getTokens(user.id, user.userName, user.roles);
    const newRefreshToken = await this.saveRefreshToken(user.id, tokens.refreshToken, userIp, userAgent, sessionId);
    return { tokens, sessionId: newRefreshToken.id, userData: {
      userId: user.id,
      userName: user.userName,
      email: user.email,
      userAvatar: user.avatar,
      isActivated: user.isActivated,
      isEmailActivated: !user.activationLink,
      isPasswordSet: !!user.password,
      banned: user.banned,
      banReason: user.banReason,
      createdAt: user.createdAt,
      updatedAt: user.updatedAt,
      roles: user.roles
    }};
  }

async refreshTokens(sessionId: number, refreshToken: string, userIp: string, userAgent: string): Promise<any> {
    const userSession = await this.tokensService.findUserSession(sessionId);

    if (!userSession)
      throw new ForbiddenException('Access Denied');

    const refreshTokenMatches = await argon2.verify(
      userSession.refreshToken,
      refreshToken,
    );
    if (!refreshTokenMatches) throw new ForbiddenException('Access Denied');

    const user = await this.usersService.getUserByIdAdmin(userSession.userId);
    const tokens = await this.getTokens(user.userId, user.userName, user.roles);
    await this.saveRefreshToken(user.userId, tokens.refreshToken, userIp, userAgent, sessionId);
    return tokens;
  }

@Module({
  providers: [RolesService],
  controllers: [RolesController],
  imports: [
    SequelizeModule.forFeature([Role, User, UserRoles])
  ],
  exports: [
    RolesService
  ]
})
export class RolesModule {}

import { Injectable } from '@nestjs/common';
import { CreateRoleDto } from "./dto/create-role.dto";
import { InjectModel } from "@nestjs/sequelize";
import { Role } from "./roles.model";

@Injectable()
export class RolesService {
    constructor(@InjectModel(Role) private roleRepository: typeof Role) {}

    async createRole(dto: CreateRoleDto) {
        const role = await this.roleRepository.create(dto);
        return role;
    }

    async getRoleByValue(value: string) {
        const role = await this.roleRepository.findOne({where: {value}});
        return role;
    }
}

import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
import * as path from 'path'
import * as fs from 'fs';
import * as sharp from 'sharp';
import { promises as fsPromises } from 'fs';

@Injectable()
export class FilesService {
    setDir(loadType: string) {
        const loadDir = 'static/user/';
        switch(loadType) {
            case 'file': 
                return loadDir + 'file';

            case 'image.orig': 
                return loadDir + 'image/orig';
            case 'image.small': 
                return loadDir + 'image/small';
            case 'image.medium': 
                return loadDir + 'image/medium';
            case 'image.high': 
                return loadDir + 'image/high';
            
            case 'avatar.small': 
                return loadDir + 'image/avatar/small';
            case 'avatar.medium': 
                return loadDir + 'image/avatar/medium';
            case 'avatar.high': 
                return loadDir + 'image/avatar/high';

            case 'room.small': 
                return loadDir + 'image/room/small';
            case 'room.medium': 
                return loadDir + 'image/room/medium';
            case 'room.high': 
                return loadDir + 'image/room/high';

            default: return loadDir + 'file';
        }
    }

    async createFile(file: Buffer, fileName: string, loadType: string, fileType: string): Promise<string> {
        const dirname = this.setDir(loadType);
        if(fileType) fileType = '.' + fileType;
        fileName = fileName + fileType;

        try {
            const filePath = path.resolve(path.resolve(__dirname, '..', '..', dirname));
            if (!fs.existsSync(filePath)) {
                fs.mkdirSync(filePath, { recursive: true });
            }
            fs.writeFileSync(path.join(filePath, fileName), file);
            return fileName;
        } catch (error) {
            console.error(error);
            throw new HttpException('Произошла ошибка при записи файла', HttpStatus.INTERNAL_SERVER_ERROR)
        }
    }

    async deleteFile(filePath: string): Promise<void> {
        try {
            await fsPromises.unlink(filePath);
        } catch (error) {
            console.error(`An error occurred while deleting the file ${filePath}:`, error);
        }
    }

    async deleteAvatar(avatarType: string, dbAvatarName: string) {
        if(!dbAvatarName) return;
        await this.deleteFile(path.join(this.setDir(`${avatarType}.small`), dbAvatarName));
        await this.deleteFile(path.join(this.setDir(`${avatarType}.medium`), dbAvatarName));
        await this.deleteFile(path.join(this.setDir(`${avatarType}.high`), dbAvatarName));
    }


    // npm update npm -g
    // npm install --os=win32 --cpu=x64 sharp
    async cropImage(inputBuffer: Buffer, resize: number, width: number, height: number, offsetX: number, offsetY: number) {
        const outputFormat = 'webp';
        return await sharp(inputBuffer.buffer)
        .rotate()
        .extract({ 
            left: offsetX, 
            top: offsetY, 
            width: width, 
            height: height 
            })
        .resize(resize)
        .webp({
            quality: 80, // 1 - 100
            lossless: false
          })
        .jpeg({
            quality: 90,
            progressive: true
          })
        .toFormat(outputFormat)
          .toBuffer();
      }

      async setAvatar(
        avatarType: string,
        image: any, 
        cropWidth: number, 
        cropHeight: number, 
        cropLeft: number, 
        cropTop: number,
        imageType: string, 
        fileName: string
      ) {
      const fileTypeOrig = image.originalname.split('.').slice(-1)
  
      await this.createFile(image.buffer, fileName, 'image.orig', fileTypeOrig);
  
      const avatarCroppedSmall = await this.cropImage(image, 128, cropWidth, cropHeight, cropLeft, cropTop);
      await this.createFile(avatarCroppedSmall, fileName, `${avatarType}.small`, imageType);
  
      const avatarCroppedMedium = await this.cropImage(image, 256, cropWidth, cropHeight, cropLeft, cropTop);
      await this.createFile(avatarCroppedMedium, fileName, `${avatarType}.medium`, imageType);
  
      const avatarCroppedHigh = await this.cropImage(image, 512, cropWidth, cropHeight, cropLeft, cropTop);
      await this.createFile(avatarCroppedHigh, fileName, `${avatarType}.high`, imageType);
    }

}

@Module({
  imports: [
    SequelizeModule.forFeature([Token])
  ],
  providers: [TokensService],
  controllers: [TokensController],
  exports: [
    TokensService
]
})
export class TokensModule {}

import { Injectable } from '@nestjs/common';
import { InjectModel } from "@nestjs/sequelize";
import { Token } from "./tokens.model";
import { TokenDto } from "./dto/token.dto";
import { User } from "../users/user.model";

@Injectable()
export class TokensService {
  constructor(@InjectModel(Token) private tokenRepository: typeof Token) {}

  async updateToken(id: number, tokenDto: TokenDto) {
    const token = await this.tokenRepository.findByPk(id);
    token.refreshToken = tokenDto.refreshToken;
      await token.save();
      return token;
  }

    async saveToken(userId: number, refreshToken: string, userIp: string, userAgent: string, sessionId?: number) {
      if(sessionId) {
        const tokenData = await this.tokenRepository.findOne({ where: { id: sessionId, userId }});
        if (tokenData) {
            tokenData.refreshToken = refreshToken;
            tokenData.userIp = userIp;
            tokenData.userAgent = userAgent;
            return tokenData.save();
        }
      }
      
      const token = await this.tokenRepository.create({ userId, refreshToken, userIp, userAgent });
      return token;
    }

    async removeToken(sessionId: number): Promise<any> {
        const isDeleted = await this.tokenRepository.destroy({ where: { id: sessionId }});
        return isDeleted;
    }

    async findUserSession(sessionId: number): Promise<any> {
      const userSession = await this.tokenRepository.findOne({ where: { id: sessionId }, 
          include: [{ model: User, attributes: ['userName'] }]
      });
      if (userSession) {
          return userSession;
      }
    }

    async getUserSessions(userId: number): Promise<any> {
      const userSessions = await this.tokenRepository.findAll({ 
        where: { userId },  
        attributes: { exclude: ['refreshToken'] },
        include: [{ model: User, attributes: ['lastSeen'] }],
        order: [['updatedAt', 'DESC']],
      });
      return userSessions;
    }


}

@Module({
  providers: [FriendsService],
  exports: [FriendsService],
  controllers: [FriendsController],
  imports: [
    SequelizeModule.forFeature([Friend])
  ],
})
export class FriendsModule {}

import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
import { InjectModel } from "@nestjs/sequelize";
import { Friend } from "./friends.model";
import { Sequelize, Op } from 'sequelize';
import { User } from "../users/user.model";
import { Profile } from "../profile/profile.model";

@Injectable()
export class FriendsService {
    constructor(@InjectModel(Friend) private friendsRepository: typeof Friend) {}

    async addFriend(from: number, to: number) {
        const friend = await this.friendsRepository.findOne({ 
          where: {
            [Op.or]: [{ from, to }, { from: to, to: from }],
          },
        });
          if (friend) {
              if(friend.from === from) { // Если я был подписан когда то
                friend.fromActive = true;
                friend.fromActiveDate  = new Date().toISOString();
              } else if(friend.to === from) { // Если на меня подписан или когда то был
                friend.toActive = true;
                friend.toActiveDate  = new Date().toISOString();
              }
              return await friend.save();
          } else {
            //const friendCreate = 
            await this.friendsRepository.create({from, to, fromActive: true, fromActiveDate: new Date().toISOString()});
            //return friendCreate;
            return { status: true}
          }
      }
  
      async deleteFriend(from: number, to: number) {
        const friend = await this.friendsRepository.findOne({ 
          where: {
            [Op.or]: [{ from, to }, { from: to, to: from }],
          },
        });
        if (friend) {
          if(friend.from === from) { // Если я был подписан когда то
            friend.fromActive = false;
            friend.fromActiveDate = new Date().toISOString();
          } else if(friend.to === from) { // Если на меня подписан или когда то был
            friend.toActive = false;
            friend.toActiveDate = new Date().toISOString();
          }
          await friend.save();
          return { status: true}
        }
      }
  
      async isFriend(from: number, to: number) { // return: notFriends, friends, subscribed, subscriber
        const friend = await this.friendsRepository.findOne({ 
          where: {
            [Op.or]: [{ from, to }, { from: to, to: from }],
          },
        });
        if (friend) {
          if(friend.from == from) { // Если я подписывался
            if(friend.fromActive === true && friend.toActive === true) { // Взаимная подписка
              return "mutually"; // Друзья
            } else if(friend.fromActive === true && friend.toActive === false) { // Я подписчик на него
              return "subscribed"; // Подписан
            } else if(friend.fromActive === false && friend.toActive === true) { // Он подписчик на меня
              return "subscriber"; // Подписчик
            } else if(friend.fromActive === false && friend.toActive === false) { // Не друзя, но когда то
              return "notFriends"; // Не друзья
            }
          } else if(friend.to == from) { // Если на меня подписывались
            if(friend.toActive === true && friend.fromActive === true) { // Взаимная подписка
              return "mutually"; // Друзья
            } else if(friend.toActive === true && friend.fromActive === false) { // Я подписчик на него
              return "subscribed"; // Подписан
            } else if(friend.toActive === false && friend.fromActive === true) { // Он подписчик на меня
              return "subscriber"; // Подписчик
            } else if(friend.toActive === false && friend.fromActive === false) { // Не друзя, но когда то
              return "notFriends"; // Не друзья
            }
          }
        } else { // Не друзья, и никогда небыли
          return "notFriends"; // Не друзья
        }
      }
  
      async getFriends(
            id: number, 
            type: string, 
            page: number = 1, 
            pageSize: number = 10
        ) {
        const offset = (page - 1) * pageSize;
        const limit = pageSize;

        let condition = [];
        switch(type) {
          default: // mutually
            condition = [{ from: id, fromActive: true, toActive: true }, { to: id, fromActive: true, toActive: true }];
          break;
          case "subscribed":
            condition = [{ from: id, fromActive: true, toActive: false }, { to: id, fromActive: false, toActive: true }];
          break;
          case "subscriber":
            condition = [{ from: id, fromActive: false, toActive: true }, { to: id, fromActive: true, toActive: false }];
          break;
        }
        const friends = await this.friendsRepository.findAndCountAll({
          where: {
            [Op.or]: condition,
          },
          limit,
          offset,
            include: [
              { 
                model: User, 
                as: 'fromUser', 
                attributes: ['id', 'userName', 'avatar'],
                include: [{
                  model: Profile,
                  as: 'profile',
                  attributes: ['firstName', 'lastName']
              }]
              },
              { 
                model: User, 
                as: 'toUser', 
                attributes: ['id', 'userName', 'avatar'],
                include: [{
                  model: Profile,
                  as: 'profile',
                  attributes: ['firstName', 'lastName']
              }]
              },
            ],
            attributes: [
              'id',
              'from',
              'to',
              'fromActive',
              'toActive'
            ]
        });
        const totalPages = Math.ceil(friends.count / pageSize); 

        const formatted = friends.rows.map(function(item) {
          let user: { id: number, userName: string, avatar: string, profile: { firstName?: string, lastName?: string } };
          
          if(item.fromUser.id === id) {
            user = item.toUser;
          } else if(item.toUser.id === id) {
            user = item.fromUser;
          }
  
          return {
            userId: user.id,
            userName: user.userName,
            avatar: user.avatar,
            firstName: user?.profile?.firstName,
            lastName: user?.profile?.lastName,
          };
        })

        return {
            friends: formatted,
            page,
            pageSize,
            totalPages,
            totalFriends: friends.count
          }
      }

  async searchFriends(
    query: string,
    id: number, 
    type: string, 
    page: number = 1, 
    pageSize: number = 10
  ) {
      const offset = (page - 1) * pageSize;
      const lowercaseQuery = `%${query.toLowerCase()}%`;

      let conditionTypeFrom: object;
      let conditionTypeTo: object;
      switch(type) {
        case "mutually":
          conditionTypeFrom = { from: id, fromActive: true, toActive: true };
          conditionTypeTo = { to: id, fromActive: true, toActive: true };
        break;
        case "subscribed":
          conditionTypeFrom = { from: id, fromActive: true, toActive: false };
          conditionTypeTo = { to: id, fromActive: false, toActive: true };
        break;
        case "subscriber":
          conditionTypeFrom = { from: id, fromActive: false, toActive: true };
          conditionTypeTo = { to: id, fromActive: true, toActive: false };
        break;
        default: throw new HttpException('friend type incorrect', HttpStatus.NOT_FOUND);
      }

      const userSearchConditionFrom = {
        [Op.or]: [
          Sequelize.where(Sequelize.fn('LOWER', Sequelize.col('fromUser.userName')), {
            [Op.like]: lowercaseQuery,
          }),
          Sequelize.where(Sequelize.fn('LOWER', Sequelize.col('fromUser.profile.firstName')), {
            [Op.like]: lowercaseQuery,
          }),
          Sequelize.where(Sequelize.fn('LOWER', Sequelize.col('fromUser.profile.lastName')), {
            [Op.like]: lowercaseQuery,
          }),
        ]
      };

      const userSearchConditionTo = {
        [Op.or]: [
          Sequelize.where(Sequelize.fn('LOWER', Sequelize.col('toUser.userName')), {
            [Op.like]: lowercaseQuery,
          }),
          Sequelize.where(Sequelize.fn('LOWER', Sequelize.col('toUser.profile.firstName')), {
            [Op.like]: lowercaseQuery,
          }),
          Sequelize.where(Sequelize.fn('LOWER', Sequelize.col('toUser.profile.lastName')), {
            [Op.like]: lowercaseQuery,
          }),
        ]
      };

      const whereCondition = {
        [Op.or]: [
          { [Op.and]: [ conditionTypeFrom, userSearchConditionTo ] }, 
          { [Op.and]: [ conditionTypeTo, userSearchConditionFrom ] }
        ]
      }

      const friends = await this.friendsRepository.findAndCountAll({
        where: whereCondition,
        limit: pageSize,
        offset,
          include: [
            { 
              model: User, 
              as: 'fromUser', 
              attributes: ['id', 'userName', 'avatar'],
              include: [{
                model: Profile,
                as: 'profile',
                attributes: ['firstName', 'lastName']
            }]
            },
            { 
              model: User, 
              as: 'toUser', 
              attributes: ['id', 'userName', 'avatar'],
              include: [{
                model: Profile,
                as: 'profile',
                attributes: ['firstName', 'lastName']
            }]
            },
          ],
          attributes: [
            'id',
            'from',
            'to',
            'fromActive',
            'toActive'
          ]
      });
      const totalPages = Math.ceil(friends.count / pageSize); 

      const formatted = friends.rows.map(function(item) {
        let user: { id: number, userName: string, avatar: string, profile: { firstName?: string, lastName?: string } };
        if(item.fromUser.id === id) {
          user = item.toUser;
        } else if(item.toUser.id === id) {
          user = item.fromUser;
        }

        return {
          id: item.id,
          userId: user.id,
          userName: user.userName,
          avatar: user.avatar,
          firstName: user?.profile?.firstName,
          lastName: user?.profile?.lastName,
        };
      })

      return {
        friends: formatted,
        page,
        pageSize,
        totalPages,
        totalFriends: friends.count
      }
  }

  async countFriends(id: number) {
      const results = await this.friendsRepository.sequelize.query(`
    SELECT
      (SELECT COUNT(*) FROM "user.friend" WHERE ("from" = ? AND "fromActive" = true AND "toActive" = true) OR ("to" = ? AND "fromActive" = true AND "toActive" = true)) AS mutually,
      (SELECT COUNT(*) FROM "user.friend" WHERE ("from" = ? AND "fromActive" = true AND "toActive" = false) OR ("to" = ? AND "fromActive" = false AND "toActive" = true)) AS subscribed,
      (SELECT COUNT(*) FROM "user.friend" WHERE ("from" = ? AND "fromActive" = false AND "toActive" = true) OR ("to" = ? AND "fromActive" = true AND "toActive" = false)) AS subscriber
  `, { replacements: [id, id, id, id, id, id] });

  return results[0][0];
}


}

@Module({
  providers: [MessageService],
  exports: [MessageService],
  controllers: [MessageController],
  imports: [
    SequelizeModule.forFeature([Message]),
    SubscribeModule, 
    RoomModule,
    UsersModule,
    FriendsModule
  ],
})
export class MessageModule {}

async createMessage(
            ownerId: number, 
            roomOrUserId: string, 
            content: string, 
            type: number, 
            replyTo: number
        ) {
        let subscribe: Subscribe;
        let roomId: number;
        let dialogueCreated = false;
        let denied: false | string = false;
        if (typeof roomOrUserId === 'string' && roomOrUserId.charAt(0) === 'u') {
          const companionId = parseInt(roomOrUserId.substring(1));
          subscribe = await this.subscribeService.getSubscribeByCompanion(ownerId, companionId);

          if(subscribe?.roomId) {
            roomId = subscribe.roomId;
          } else {
            denied = await this.userCheck(ownerId, companionId);
            if(denied) return { denied };

            const createdDialogue = await this.roomService.createDialogue(ownerId, companionId);
            roomId = createdDialogue.roomCreate.id;
            dialogueCreated = true;
          }
        } else { 
            roomId = parseInt(roomOrUserId); 
        }

        const subscribeRoom = await this.subscribeService.getSubscribe(ownerId, roomId);

        if(!subscribeRoom?.dataValues && !subscribeRoom?.dataValues.isSubscribed) return { denied: 'roomSubscribersOnly' };
        if(!subscribeRoom?.dataValues.isApproved) return { denied: 'roomNotApproved' };
        if(subscribeRoom?.dataValues.banned) return { denied: 'userBan' };

        if(subscribeRoom.dataValues.subscribeRoom.type === RoomType.dialogue) {
            if(!dialogueCreated) { 
                denied = await this.userCheck(ownerId, subscribeRoom.dataValues.companionId);
                if(denied) return { denied }; 
            }
            
        }

        if(subscribeRoom.subscribeRoom.banned) return { denied: 'roomBanned' };
        if(subscribeRoom.subscribeRoom.isDeleted) return { denied: 'roomDeleted' };
        if(subscribeRoom.subscribeRoom.readonly) return { denied: 'roomReadonly' };


        if(subscribeRoom.subscribeRoom.type === RoomType.channel) {
            if(
                subscribeRoom.userRole === SubscribeRole.subscriber || 
                subscribeRoom.userRole === SubscribeRole.nobody
                ) return { denied: 'roomRole' };
        }


        replyTo = replyTo || null;
        const createdMessage = await this.messageRepository.create({ 
            owner: ownerId, 
            room: roomId, 
            content, 
            type, 
            replyTo 
        });
        if(!createdMessage.id) throw new WsException('Create message error'); 
        return { 
            denied,
            dialogueCreated,
            createdMessage 
        };
    }

async getMessages(
            user: object,
            roomId: number, 
            page: number = 1, 
            pageSize: number = 10
        ): Promise<any> {

        const ownerId = user['sub'];
        const isPrivileged = user['roles'].some(role => ['ADMIN', 'MODERATOR'].includes(role.value));

        const room = await this.roomService.getRoom(roomId);
        const subscribe = await this.subscribeService.getSubscribe(ownerId, roomId);

        if(room?.dataValues.banned && !isPrivileged) return { denied: 'roomBanned' };
        if(room?.dataValues.isDeleted && !isPrivileged) return { denied: 'roomDeleted' };

        if(room.dataValues.type !== RoomType.dialogue) {
            if(room?.dataValues?.privacy !== RoomPrivacy.all) {
                if(!subscribe?.dataValues && !subscribe?.dataValues.isSubscribed) return { denied: 'roomSubscribersOnly' };
                if(!subscribe?.dataValues.isApproved) return { denied: 'roomNotApproved' };
                if(subscribe?.dataValues.banned)  return { denied: 'userBan' };
            }
         } else {
            if(!subscribe?.dataValues && !subscribe.dataValues.isSubscribed  && !isPrivileged) return { denied: 'roomSubscribersOnly' };
         }
        
        const offset = (page - 1) * pageSize;
        const limit = pageSize;
        const messages = await this.messageRepository.findAndCountAll({
            where: { room: roomId,
            },
            order: [['id', 'DESC']],
            limit,
            offset,
            include: [
                { model: User, as: 'ownerUser', attributes: ['userName', 'avatar'] },
                { model: Message, as: 'replyToMessage' }
            ]
        });
        const totalPages = Math.ceil(messages.count / pageSize);
        return {
            denied: false,
            messages: messages.rows,
            page,
            pageSize,
            totalPages,
            totalMessages: messages.count
          }
    }

@Module({
  providers: [RoomService],
  controllers: [RoomController],
  imports: [
    SequelizeModule.forFeature([Room, User, Message]),
    forwardRef(() => SubscribeModule),
    FilesModule,
    UsersModule,
    FriendsModule
  ],
  exports: [RoomService],
})
export class RoomModule {}

async createRoom(
        ownerId: number,
        isPriveleged: boolean,
        type: number,
        name: string,
        privacy: number,
        about: string,
      ) {

        if(!isPriveleged) {
          if(privacy === RoomPrivacy.privileged) throw new HttpException('Нет доступа', HttpStatus.FORBIDDEN);
        }

        const roomExists = await this.getRoomByName(name);
        if (roomExists) throw new HttpException('Название уже занято', HttpStatus.BAD_REQUEST);
        const roomCreate = await this.roomRepository.create({ ownerId, type, name, privacy, about, creatorId: ownerId });
        if(!roomCreate?.dataValues?.id) throw new HttpException('Ошибка создания', HttpStatus.INTERNAL_SERVER_ERROR);
        const subscribe = await this.subscribeService.subscribe(ownerId, roomCreate.id, SubscribeRole.owner, isPriveleged);
        return { roomCreate, subscribe };
      }

async createDialogue(fromUserId: number, toUserId: number ) {
        if(fromUserId === toUserId) throw new HttpException('You can\'t write to yourself', HttpStatus.INTERNAL_SERVER_ERROR);
          const roomCreate = await this.roomRepository.create({ type: RoomType.dialogue, creatorId: fromUserId });
          if(roomCreate?.dataValues?.id) {
            const subscribeFrom = await this.subscribeService.subscribeDialogue(roomCreate.id, fromUserId, toUserId);
            const subscribeTo = await this.subscribeService.subscribeDialogue(roomCreate.id, toUserId, fromUserId);

            if(subscribeFrom?.dataValues?.id && subscribeTo?.dataValues?.id) { 
              return { 
                roomCreate,
                subscribeFrom,
              }

            }  else throw new HttpException('Create room subscribe error', HttpStatus.INTERNAL_SERVER_ERROR);
          } else throw new HttpException('Create room error', HttpStatus.INTERNAL_SERVER_ERROR);
      }

async getRoomData(idMixed: string, user: object) {
        let subscribe: Subscribe;
        let roomId: number;
        let companionId: number;
        let isBannedCompanion = false;
        if (idMixed.charAt(0) === 'u') {
          companionId = parseInt(idMixed.substring(1));

          subscribe = await this.subscribeService.getSubscribeByCompanion(user['sub'], companionId);

          if(!subscribe?.roomId) {
            const userData = await this.usersService.getUserByIdPublic(companionId);
            if(!userData) throw new HttpException('User not found', HttpStatus.NOT_FOUND);

            const userPrivacyAccess = await this.isAccessFriend(userData.msgPrivacy, user['sub'], companionId);

            return { 
              type: RoomType.initDialogue, 
              denied: userPrivacyAccess ? false : 'userPrivacy',
              user: userData
            }
          }
          
          roomId = subscribe.roomId;
        } else {
          roomId = parseInt(idMixed);
          subscribe = await this.subscribeService.getSubscribe(user['sub'], roomId);
          companionId = subscribe?.companionId;
        }

        const room = await this.getRoom(roomId);

        if(companionId) {
          const companionSubscribe = await this.subscribeService.getSubscribe(companionId, roomId);
          isBannedCompanion = companionSubscribe.banned;
        }

        const isPrivileged = user['roles'].some(role => ['ADMIN', 'MODERATOR'].includes(role.value));
        const isSelf = user['sub'] === room.ownerId;
        const isAll = room.privacy === RoomPrivacy.all;
        const isApproval = room.privacy === RoomPrivacy.approval;
        const isByInvitation = room.privacy === RoomPrivacy.byInvitation;
        const isBanned = room.banned || false;
        const isSubscriber = subscribe?.isSubscribed || false;
        const isApproved = subscribe?.isApproved || false;
        const isDialogue = room.type === RoomType.dialogue;
        const isDeleted = room.isDeleted || false;

        let isDenied:  boolean | string  = false;
        if(subscribe?.banned) isDenied = 'userBan';
        if(subscribe?.companionUser?.banned) isDenied = 'adminUserBan';
        if(room?.banned) isDenied = 'roomBanned';
        if(room?.isDeleted) isDenied = 'roomDeleted';
        if(room?.readonly) isDenied = 'roomReadonly';

        if(room?.privacy !== 1 && !isSubscriber) isDenied = 'roomSubscribersOnly';
        
        const responseFull = {
          responceType: 'full',
          denied: isDenied,
          id: room.id,
          ownerId: room.ownerId,
          creatorId: room.creatorId,
          type: room.type,
          name: room.name,
          about: room.about,
          roomAvatar: room.roomAvatar,
          privacy: room.privacy,
          banned: room.banned,
          banReason: room.banReason,
          bannedAt: room.bannedAt,
          isDeleted: room.isDeleted,
          disableEdit: room.disableEdit,
          readonly: room.readonly,
          moderated: room.moderated,
          createdAt: room.createdAt,
          updatedAt: room.updatedAt,
          countSubscribers: room.countSubscribers,
          ownerUser: room.ownerUser,
          creatorUser: room.creatorUser,
          subscribe
        }

        const responseApproval = {
            responceType: 'approval',
            denied: isDenied,
            id: room.id,
            type: room.type,
            name: room.name,
            about: room.about,
            roomAvatar: room.roomAvatar,
            privacy: room.privacy,
            banned: room.banned,
            banReason: room.banReason,
            bannedAt: room.bannedAt,
            isDeleted: room.isDeleted,
            countSubscribers: room.countSubscribers,
            subscribe
        };

        const responseDialogue = {
          denied: isDenied,
          isBannedCompanion,
          type: room.type,
          id: room.id,
          createdAt: room.createdAt,
          subscribe
        };

        const responseAccessDenied = {
          denied: isDenied,
          id: room.id,
          type: room.type,
          privacy: room.privacy,
          banned: room.banned,
          banReason: room.banReason,
          bannedAt: room.bannedAt,
          isDeleted: room.isDeleted,
          subscribe
        };

        if(isDialogue && isSubscriber) return responseDialogue;
        if(isDeleted && isPrivileged) return responseFull;
        if(isBanned && isPrivileged) return responseFull;
        if(isPrivileged) return responseFull;
        if(isSelf) return responseFull;
        if(isApproval && isApproved) return responseFull;
        if(isApproval && !isApproved) return responseApproval;
        if(isByInvitation && isApproved) return responseFull;
        if(isAll) return responseFull;
        return responseAccessDenied;
      }