File

src/service/1.0.0/user.service.ts

Index

Methods

Constructor

constructor(userRepository: Repository, groupRepository: Repository, userCourseRepository: Repository, courseRepository: Repository, userUniqueFiledRepository: Repository, emailService: EmailService, jwtService: JwtService)
Parameters :
Name Type Optional
userRepository Repository<User> No
groupRepository Repository<Group> No
userCourseRepository Repository<UserCourse> No
courseRepository Repository<Course> No
userUniqueFiledRepository Repository<UserUniqueFiled> No
emailService EmailService No
jwtService JwtService No

Methods

Private Async codeGenerator
codeGenerator()
Returns : {}
Async createAdminOrTrainer
createAdminOrTrainer(params: AddAdminOrTrainerDTO)
Parameters :
Name Type Optional
params AddAdminOrTrainerDTO No
Returns : {}
Async createNewUser
createNewUser(params: any)
Parameters :
Name Type Optional
params any No
Returns : {}
Async createNewUserFromCMSbyAdmin
createNewUserFromCMSbyAdmin(params: RegistrationFromCMSDTO)
Parameters :
Name Type Optional
params RegistrationFromCMSDTO No
Returns : {}
Async deactiavateUser
deactiavateUser(userId)
Parameters :
Name Optional
userId No
Returns : {}
Async deactivateAndActivateUsersById
deactivateAndActivateUsersById(userId: any)
Parameters :
Name Type Optional
userId any No
Returns : {}
Async deleteUser
deleteUser(userId)
Parameters :
Name Optional
userId No
Returns : {}
Async deleteUsersByIds
deleteUsersByIds(params: any)
Parameters :
Name Type Optional
params any No
Returns : {}
Async editUser
editUser(params: any)
Parameters :
Name Type Optional
params any No
Returns : {}
Async editUserFromProfile
editUserFromProfile(params: EditUserDataFromCMSDTO)
Parameters :
Name Type Optional
params EditUserDataFromCMSDTO No
Returns : {}
Async forgotPassword
forgotPassword(email: string)
Parameters :
Name Type Optional
email string No
Returns : {}
Async generateID
generateID()
Returns : {}
Private generatePassword
generatePassword(length: number)
Parameters :
Name Type Optional Default value
length number No 8
Returns : string
Async getAllAdmin
getAllAdmin()
Returns : Promise<any[]>
Async getAllFilteredUserWithoutAdmin
getAllFilteredUserWithoutAdmin()
Returns : Promise<any[]>
Async getAllMaintainer
getAllMaintainer()
Returns : Promise<any[]>
Async getAllPlayer
getAllPlayer()
Returns : Promise<any[]>
Async getAllUsers
getAllUsers()
Returns : Promise<User[]>
Async getOneUser
getOneUser(userId)
Parameters :
Name Optional
userId No
Returns : {}
Async getUserByCourse
getUserByCourse(courseId: Number)
Parameters :
Name Type Optional
courseId Number No
Returns : {}
Async getUserByCourseExam
getUserByCourseExam(courseId: Number)
Parameters :
Name Type Optional
courseId Number No
Returns : {}
Async getUserCourses
getUserCourses(userId: number)
Parameters :
Name Type Optional
userId number No
Returns : {}
Async loginWithQrCode
loginWithQrCode(params: QrLoginDTO)
Parameters :
Name Type Optional
params QrLoginDTO No
Returns : {}
Async modifyAdminAndTrainer
modifyAdminAndTrainer(params: ModifyAdminDTO)
Parameters :
Name Type Optional
params ModifyAdminDTO No
Returns : {}
Async modifyUser
modifyUser(params: ModifyUserDTO)
Parameters :
Name Type Optional
params ModifyUserDTO No
Returns : {}
Async registration
registration(params: RegistrationDTO)
Parameters :
Name Type Optional
params RegistrationDTO No
Returns : {}
import { Injectable } from "@nestjs/common";
import { InjectRepository } from "@nestjs/typeorm";
import { Repository } from "typeorm";
import { User } from "../../entity/user.entity";
import { UserWithEmailAlreadyExistsException } from "../../exception/user/user-with-email-already-exists.exception";
import { ApiException } from "../../module/routing/exception/api.exception";
import { RegistrationDTO } from "../../dto/1.0.0/user/registration.dto";
import { UserNotFoundException } from "../../exception/user/user-not-found.exception";
import { ModifyUserDTO } from "src/dto/1.0.0/user/modifyuser.dto";
import * as nodemailer from "nodemailer";
import { RegistrationFromCMSDTO } from "src/dto/1.0.0/user/registration-from-cms.dto";
import { Group } from "src/entity/group.entity";
import { GroupNotFoundException } from "src/exception/group/group-not-found.exception";
import { EmailService } from "./email.service";
import { UserCourse } from "src/entity/user-course.entity";
import { QrNotValidException } from "src/exception/course/qr-not-valid.exception";
import { Course } from "src/entity/course.entity";
import { QrLoginDTO } from "src/dto/1.0.0/user/qr-login.dto";
import { JwtService } from "@nestjs/jwt";
import { ROLES } from "src/constant/roles.contant";
import { UserCourseModelDTO } from "src/dto/1.0.0/user/user-course-model.dto";
import { v4 } from "uuid";
import { COURSE_TYPE } from "src/constant/global.constant";
import { UserCodeDefined } from "src/exception/user/user-code-defined.exception";
import { UserUniqueFiled } from "src/entity/user-unique-field.entity";
import { ModifyAdminDTO } from "src/dto/1.0.0/user/modify-admin.dto";
import * as bcrypt from "bcryptjs";
import { AddAdminOrTrainerDTO } from "src/dto/1.0.0/user/add-admin-or-trainer.dto";
import { EditCourseFromCMSDTO } from "src/dto/1.0.0/course/edit-course-from-cms.dto";
import { EditUserDataFromCMSDTO } from "src/dto/1.0.0/user/edit-user-data-from-cms.dto";
import { UserPasswordNotValidException } from "src/exception/user/user-password-not-valid";

@Injectable()
export class UserService100 {
  constructor(
    @InjectRepository(User)
    private readonly userRepository: Repository<User>,
    @InjectRepository(Group)
    private readonly groupRepository: Repository<Group>,
    @InjectRepository(UserCourse)
    private readonly userCourseRepository: Repository<UserCourse>,
    @InjectRepository(Course)
    private readonly courseRepository: Repository<Course>,
    @InjectRepository(UserUniqueFiled)
    private readonly userUniqueFiledRepository: Repository<UserUniqueFiled>,
    private readonly emailService: EmailService,
    private readonly jwtService: JwtService
  ) {}

  private async codeGenerator() {
    const randomNumber = Math.floor(Math.random() * 8999999999 + 100000);
    //random elenőrzése a feltételeknem megfelel-e
    for (let index = 0; index <= 10; index++) {
      if (randomNumber[index] === randomNumber[index - 1]) {
        this.codeGenerator;
      }
    }
    //egymást követő karrakterek láncolata nem lehet növekvő
    if (
      randomNumber[1] === randomNumber[0] + 1 &&
      randomNumber[2] === randomNumber[1] + 1 &&
      randomNumber[3] === randomNumber[2] + 1 &&
      randomNumber[4] === randomNumber[3] + 1 &&
      randomNumber[5] === randomNumber[4] + 1
    ) {
      this.codeGenerator;
    }
    //egymást követő karrakterek láncolata nem lehet csökkenő
    if (
      randomNumber[0] === randomNumber[1] - 1 &&
      randomNumber[1] === randomNumber[2] - 1 &&
      randomNumber[2] === randomNumber[3] - 1 &&
      randomNumber[3] === randomNumber[4] - 1 &&
      randomNumber[4] === randomNumber[5] - 1
    ) {
      this.codeGenerator;
    }
    //Nem lehet létező code
    const familys = await this.userRepository.find();
    if (familys.length === 0) {
      return randomNumber;
    }

    for (let index = 0; index < familys.length; index++) {
      const element = familys[index];
      if (element.generatedID === randomNumber.toString()) {
        this.codeGenerator();
      } else {
        return randomNumber;
      }
    }
  }

  async generateID() {
    return await this.codeGenerator();
  }
  async registration(params: RegistrationDTO) {
    let user = this.userRepository.create();

    if ((await this.userRepository.count({ email: params.email })) > 0) {
      throw new UserWithEmailAlreadyExistsException();
    }

    user.email = params.email;
    user.password = params.password;

    user = await this.userRepository.save(user);

    return await this.userRepository.findOne(user.id);
  }

  private generatePassword(length = 8): string {
    const pw_characters = "abcdefghijklmnopqrstvxyz0123456789";

    let pw = "";

    for (let index = 0; index < length; index++) {
      let char = pw_characters.charAt(
        Math.floor(Math.random() * pw_characters.length)
      );
      pw += Math.floor(Math.random() * 2) === 0 ? char.toUpperCase() : char;
    }

    return pw;
  }

  async getAllUsers(): Promise<User[]> {
    return await this.userRepository.find();
  }

  async deactiavateUser(userId) {
    // return await this.userRepository.delete(userId);
    const user = await this.userRepository.findOne({ where: { id: userId } });
    user.isActive = false;
    await this.userRepository.save(user);
    return user;
  }
  async deleteUser(userId) {
    return await this.userRepository.delete(userId);
  }

  async getOneUser(userId) {
    return await this.userRepository.findOne({
      where: { id: userId },
      relations: ["userUniqueField"],
    });
  }

  async forgotPassword(email: string) {
    let forgotUser = await this.userRepository.findOne({
      where: { email: email },
    });
    if (forgotUser === undefined) {
      throw new UserNotFoundException();
    }

    const password = this.generatePassword(8);

    forgotUser.password = password;

    forgotUser = await this.userRepository.save(forgotUser);

    forgotUser = await this.userRepository.findOne(forgotUser.id);

    //email küldés
    let transporter = nodemailer.createTransport({
      host: process.env.EMAIL_HOST,
      port: 587,
      secure: false, // true for 465, false for other ports
      auth: {
        user: process.env.EMAIL_USER, // generated ethereal user
        pass: process.env.EMAIL_PASS, // generated ethereal password
      },
    });

    let info = await transporter.sendMail({
      from: process.env.EMAIL_USER, // sender address
      to: forgotUser.email, // list of receivers
      subject: "Neue Passwort", // Subject line
      text: "Új jelszó" + password, // plain text body
      //html: "<b>Hello world?</b>", // html body
    });

    return forgotUser;
  }

  async getAllFilteredUserWithoutAdmin(): Promise<any[]> {
    const userList = await this.userRepository.find({ relations: ["group"] });
    const filtered = userList.filter((item) => item.group.id !== ROLES.admin);

    const sendUserData = filtered.map((item) => {
      return {
        id: item.id,
        group: item.group.name,
        name: item.firstName + " " + item.lastName,
        fristName: item.firstName,
        lastName: item.lastName,
        email: item.email,
        isActive: item.isActive,
      };
    });
    return sendUserData;
  }

  async getAllPlayer(): Promise<any[]> {
    const userList = await this.userRepository.find({ relations: ["group"] });
    const filtered = userList.filter((item) => item.group.id === ROLES.user);

    const sendUserData = filtered.map((item) => {
      return {
        id: item.id,
        group: item.group.name,
        name: item.firstName + " " + item.lastName,
        fristName: item.firstName,
        lastName: item.lastName,
        email: item.email,
        isActive: item.isActive,
      };
    });
    return sendUserData;
  }

  async getAllAdmin(): Promise<any[]> {
    const userList = await this.userRepository.find({ relations: ["group"] });
    const filtered = userList.filter((item) => item.group.id === ROLES.admin);

    const sendUserData = filtered.map((item) => {
      return {
        id: item.id,
        group: item.group.name,
        name: item.firstName + " " + item.lastName,
        fristName: item.firstName,
        lastName: item.lastName,
        email: item.email,
        isActive: item.isActive,
      };
    });
    return sendUserData;
  }

  async getAllMaintainer(): Promise<any[]> {
    const userList = await this.userRepository.find({ relations: ["group"] });
    const filtered = userList.filter(
      (item) => item.group.id === ROLES.maintainer
    );

    const sendUserData = filtered.map((item) => {
      return {
        id: item.id,
        group: item.group.name,
        name: item.firstName + " " + item.lastName,
        fristName: item.firstName,
        lastName: item.lastName,
        email: item.email,
        isActive: item.isActive,
      };
    });
    return sendUserData;
  }
  async createNewUserFromCMSbyAdmin(params: RegistrationFromCMSDTO) {
    let user = this.userRepository.create();

    if ((await this.userRepository.count({ email: params.email })) > 0) {
      throw new UserWithEmailAlreadyExistsException();
    }

    const group = await this.groupRepository.findOne({
      where: { id: params.groupId },
    });

    if (!group) {
      throw new GroupNotFoundException();
    }

    user.email = params.email;
    user.group = group;
    const password = this.generatePassword(8);
    user.password = password;
    user.firstName = params.firstName;
    user.lastName = params.lastName;
    try {
      const subject = "VR tanoda felhasználói adatok";
      await this.emailService.sendEmail(
        "create-new-user",
        [params.email],
        subject,
        {
          subject,
          name: params.firstName + " " + params.lastName,
          password: password,
        }
      );
    } catch (error) {
      console.log(error);

      throw new ApiException();
    }
    user = await this.userRepository.save(user);

    return await this.userRepository.findOne(user.id);
  }

  async deleteUsersByIds(params: any) {
    await Promise.all(
      params.ids.map(async (item) => {
        let actUser = await this.userRepository.findOne(item);
        actUser.isActive = false;
        await this.userRepository.save(actUser);
      })
    );
    return { deleted: true };
  }
  async deactivateAndActivateUsersById(userId: any) {
    let actUser = await this.userRepository.findOne({ where: { id: userId } });
    actUser.isActive = !actUser.isActive;
    await this.userRepository.save(actUser);
    return { isActive: actUser.isActive };
  }

  async modifyUser(params: ModifyUserDTO) {
    let userToUpdate = await this.userRepository.findOne(params.id);

    if (
      params.email !== userToUpdate.email &&
      (await this.userRepository.count({ email: params.email })) > 0
    ) {
      throw new UserWithEmailAlreadyExistsException();
    }

    userToUpdate.email = params.email;
    if (params.password !== "") {
      userToUpdate.password = params.password;
    }
    //userToUpdate.name = params.name;
    if (params.firstName !== "") {
      userToUpdate.firstName = params.firstName;
    }
    if (params.lastName !== "") {
      userToUpdate.lastName = params.lastName;
    }
    if (params.groupId) {
      const group = await this.groupRepository.findOne({
        where: { id: params.groupId },
      });
      userToUpdate.group = group;
    }

    userToUpdate = await this.userRepository.save(userToUpdate);

    return await this.userRepository.findOne(userToUpdate.id);
  }

  async modifyAdminAndTrainer(params: ModifyAdminDTO) {
    let userToUpdate = await this.userRepository.findOne(params.id);

    if (
      params.email !== userToUpdate.email &&
      (await this.userRepository.count({ email: params.email })) > 0
    ) {
      throw new UserWithEmailAlreadyExistsException();
    }

    userToUpdate.email = params.email;
    if (params.password && params.password !== "") {
      userToUpdate.password = params.password;
    }
    //userToUpdate.name = params.name;
    if (params.firstName !== "") {
      userToUpdate.firstName = params.firstName;
    }
    if (params.lastName !== "") {
      userToUpdate.lastName = params.lastName;
    }
    userToUpdate.rank = params.rank;

    if (params.workStartDate) {
      userToUpdate.workStartDate = new Date(params.workStartDate * 1000);
    }

    userToUpdate = await this.userRepository.save(userToUpdate);

    return await this.userRepository.findOne(userToUpdate.id);
  }

  async loginWithQrCode(params: QrLoginDTO) {
    const findedUserCourse = await this.userCourseRepository.findOne({
      where: { qrCode: params.qrcode },
    });
    if (!findedUserCourse) {
      throw new QrNotValidException();
    }
    const findedUser = await this.userRepository.findOne({
      where: { id: findedUserCourse.userId, isActive: true},
    });
    if (!findedUser) {
      throw new UserNotFoundException()
    }
    const findedCourse = await this.courseRepository.findOne({
      where: { id: findedUserCourse.courseId },
    });

    return {
      user: findedUser,
      courseId: findedCourse.id,
      userCourseId: findedUserCourse.id,
      accessToken: this.jwtService.sign({
        sub: findedUser.id,
      }),
    };
  }
  //gyakroló tipus
  async getUserByCourse(courseId: Number) {
    const findedUserCourse = await this.userCourseRepository.find({
      where: {
        courseId: courseId,
        courseTypeId: COURSE_TYPE.practice,
        isActive: true,
      },
      relations: ["user", "user.group"],
    });
    const findedCourse = await this.courseRepository.findOne({
      where: { id: courseId },
    });
    const allUser = await this.userRepository.find({
      where: { groupId: ROLES.user },
    });
    let filteredUsers = [];
    let allUserWithoutcourseUser = [];
    let filteredUsersIds = [];
    const filterFindedUserCourse = findedUserCourse.filter(
      (item) => item.user.groupId === ROLES.user
    );
    for (let index = 0; index < filterFindedUserCourse.length; index++) {
      const element = filterFindedUserCourse[index];
      const user = await this.userRepository.findOne({
        where: { id: element.userId, isActive: true },
      });
      if (user) {
        const convertedUser = new UserCourseModelDTO();
        convertedUser.id = v4();
        convertedUser.course = element.course;
        convertedUser.user = user;
        convertedUser.qr = element.qrCode;
        filteredUsers = [...filteredUsers, convertedUser];
        filteredUsersIds = [...filteredUsersIds, user.id];
      }
    }
    const allUserWithoutCourseUser = allUser.filter(
      (x) => !filteredUsersIds.includes(x.id)
    );

    for (let index = 0; index < allUserWithoutCourseUser.length; index++) {
      const element = allUserWithoutCourseUser[index];

      const convertedUser = new UserCourseModelDTO();
      convertedUser.id = v4();
      convertedUser.course = findedCourse;
      convertedUser.user = element;
      convertedUser.qr = v4();
      allUserWithoutcourseUser = [...allUserWithoutcourseUser, convertedUser];
    }

    return {
      users: {
        courseUsers: filteredUsers,
        allUserWithoutCourseUser: allUserWithoutcourseUser,
      },
    };
  }
  //Vizsga tipus
  async getUserByCourseExam(courseId: Number) {
    const findedUserCourse = await this.userCourseRepository.find({
      where: {
        courseId: courseId,
        courseTypeId: COURSE_TYPE.exam,
        isActive: true,
      },
      relations: ["user", "user.group"],
    });
    const findedCourse = await this.courseRepository.findOne({
      where: { id: courseId },
    });
    const allUser = await this.userRepository.find({
      where: { groupId: ROLES.user },
    });
    let filteredUsers = [];
    let allUserWithoutcourseUser = [];
    let filteredUsersIds = [];
    const filterFindedUserCourse = findedUserCourse.filter(
      (item) => item.user.groupId === ROLES.user
    );
    for (let index = 0; index < filterFindedUserCourse.length; index++) {
      const element = filterFindedUserCourse[index];
      const user = await this.userRepository.findOne({
        where: { id: element.userId, isActive: true },
      });
      if (user) {
        const convertedUser = new UserCourseModelDTO();
        convertedUser.id = v4();
        convertedUser.course = element.course;
        convertedUser.user = user;
        convertedUser.qr = element.qrCode;
        convertedUser.succesfulExam = element.examSuccessful;
        filteredUsers = [...filteredUsers, convertedUser];
        filteredUsersIds = [...filteredUsersIds, user.id];
      }
    }
    const allUserWithoutCourseUser = allUser.filter(
      (x) => !filteredUsersIds.includes(x.id)
    );

    for (let index = 0; index < allUserWithoutCourseUser.length; index++) {
      const element = allUserWithoutCourseUser[index];

      const convertedUser = new UserCourseModelDTO();
      convertedUser.id = v4();
      convertedUser.course = findedCourse;
      convertedUser.user = element;
      convertedUser.succesfulExam = false;
      convertedUser.qr = v4();
      allUserWithoutcourseUser = [...allUserWithoutcourseUser, convertedUser];
    }

    return {
      users: {
        courseUsers: filteredUsers,
        allUserWithoutCourseUser: allUserWithoutcourseUser,
      },
    };
  }

  async editUser(params: any) {
    let findedUser = await this.userRepository.findOne({
      where: { id: params.userId },
      relations: ["userUniqueField"],
    });
    findedUser.firstName = params.firstName;
    findedUser.lastName = params.lastName;
    findedUser.genderIdentity = params.gender;
    findedUser.generatedID = params.userCode;
    findedUser.organizationalUnit = params.organizationalUnit;
    findedUser.workStartDate = new Date(params.workStartDate * 1000);
    findedUser.birthDate = new Date(params.birthDate * 1000);
    findedUser.jobGroup = params.workGroup;
    findedUser.groupId = ROLES.user;
    findedUser = await this.userRepository.save(findedUser);

    if (params.uniquefileds.length > 0) {
      const findedUSerOrganitations = await this.userUniqueFiledRepository.find(
        { where: { user: findedUser } }
      );
      //törlöm az eddigieket
      for (let index = 0; index < findedUSerOrganitations.length; index++) {
        const element = findedUSerOrganitations[index];
        await this.userUniqueFiledRepository.delete(element.id);
      }
      //hozzáadom az újakat.
      for (let index = 0; index < params.uniquefileds.length; index++) {
        const element = params.uniquefileds[index];
        const newUniqueField = this.userUniqueFiledRepository.create();
        newUniqueField.user = findedUser;
        newUniqueField.value = element.value;
        await this.userUniqueFiledRepository.save(newUniqueField);
      }
    }

    return {
      success: true,
    };
  }
  async editUserFromProfile(params: EditUserDataFromCMSDTO) {
    let findedUser = await this.userRepository.findOne({
      where: { id: params.id },
      relations: ["userUniqueField"],
    });
    if (
      findedUser === undefined ||
      !bcrypt.compareSync(params.oldPassWord, findedUser.password)
    ) {
      throw new UserPasswordNotValidException();
    }
    if (params.newPassword && params.newPassword.trim() !== "") {
      findedUser.password === params.newPassword 
     }

    findedUser.firstName = params.firstName;
    findedUser.lastName = params.lastName;
    findedUser = await this.userRepository.save(findedUser);

    return {
      success: true,
    };
  }
  async createNewUser(params: any) {
    const allUser = await this.userRepository.findOne({
      where: { generatedID: params.userCode },
    });
    if (allUser) {
      throw new UserCodeDefined();
    }

    let newUser = this.userRepository.create();
    newUser.firstName = params.firstName;
    newUser.lastName = params.lastName;
    newUser.genderIdentity = params.gender;
    newUser.generatedID = params.userCode;
    newUser.organizationalUnit = params.organizationalUnit;
    newUser.workStartDate = new Date(params.workStartDate * 1000);
    newUser.birthDate = new Date(params.birthDate * 1000);
    newUser.jobGroup = params.workGroup;
    newUser.groupId = ROLES.user;
    newUser = await this.userRepository.save(newUser);

    if (params.uniquefileds.length > 0) {
      for (let index = 0; index < params.uniquefileds.length; index++) {
        const element = params.uniquefileds[index];
        const newUniqueField = this.userUniqueFiledRepository.create();
        newUniqueField.user = newUser;
        newUniqueField.value = element.value;
        await this.userUniqueFiledRepository.save(newUniqueField);
      }
    }

    return {
      success: true,
    };
  }
  async createAdminOrTrainer(params: AddAdminOrTrainerDTO) {
    const group = await this.groupRepository.findOne({
      where: { id: params.groupId },
    });
    if ((await this.userRepository.count({ email: params.email })) > 0) {
      throw new UserWithEmailAlreadyExistsException();
    }
    let newUser = this.userRepository.create();
    newUser.firstName = params.firstName;
    newUser.lastName = params.lastName;
    newUser.rank = params.rank;
    newUser.email = params.email;
    newUser.workStartDate = new Date(params.workStartDate * 1000);
    newUser.group = group;
    newUser.password = bcrypt.hashSync(params.password);
    newUser = await this.userRepository.save(newUser);

    return {
      success: true,
    };
  }
  async getUserCourses(userId: number) {
    const user = await this.userRepository.findOne({ id: userId });
    const userCourse = await this.userCourseRepository.find({
      where: { user: user },
      relations: ["course", "courseType"],
    });
    return userCourse;
  }
}

result-matching ""

    No results matching ""