File

src/service/1.0.0/file-descriptor.service.ts

Index

Methods

Constructor

constructor(coursespository: Repository, fileRepository: Repository, userRepository: Repository, userCourseRepository: Repository, courseTypeRepository: Repository, courseFileRepository: Repository, fileTypeRepository: Repository, pdfService: PdfService)
Parameters :
Name Type Optional
coursespository Repository<Course> No
fileRepository Repository<Files> No
userRepository Repository<User> No
userCourseRepository Repository<UserCourse> No
courseTypeRepository Repository<CourseType> No
courseFileRepository Repository<FilesCourse> No
fileTypeRepository Repository<FileType> No
pdfService PdfService No

Methods

Async deleteFile
deleteFile(params: DeleteFileDTO)
Parameters :
Name Type Optional
params DeleteFileDTO No
Returns : {}
Async deleteFileByFileId
deleteFileByFileId(fileId: any)
Parameters :
Name Type Optional
fileId any No
Returns : {}
Async deleteFileByFileIdAndCourseId
deleteFileByFileIdAndCourseId(fileId: Number, courseId: Number)
Parameters :
Name Type Optional
fileId Number No
courseId Number No
Returns : {}
Async genareateAllUserExamPDF
genareateAllUserExamPDF(params: any)
Parameters :
Name Type Optional
params any No
Returns : {}
Async generateAndSavePDF
generateAndSavePDF(params: any)
Parameters :
Name Type Optional
params any No
Returns : {}
Async generateCourseDocumentationCMS
generateCourseDocumentationCMS(id: Number)
Parameters :
Name Type Optional
id Number No
Returns : {}
Async generateCourseDocumentationPDF
generateCourseDocumentationPDF(id: Number)
Parameters :
Name Type Optional
id Number No
Returns : {}
Async getAllFiles
getAllFiles()
Returns : {}
Async getCoursesByFile
getCoursesByFile(fileId: Number)
Parameters :
Name Type Optional
fileId Number No
Returns : {}
Async getFilesByCourseId
getFilesByCourseId(courseId: number)
Parameters :
Name Type Optional
courseId number No
Returns : {}
Private Async pdfGenerateUser
pdfGenerateUser(params: QrPdfGenerateDTO)
Parameters :
Name Type Optional
params QrPdfGenerateDTO No
Returns : {}
Async updateDocumentWithPicture
updateDocumentWithPicture(file, id)
Parameters :
Name Optional
file No
id No
Returns : any
Async uploadFiles
uploadFiles(files: any, tag: string)
Parameters :
Name Type Optional
files any No
tag string No
Returns : {}
Async uploadFileToCourse
uploadFileToCourse(courseId: number, files: any, params: CreateFileCheckGlobalDTO)
Parameters :
Name Type Optional
courseId number No
files any No
params CreateFileCheckGlobalDTO No
Returns : {}
import { Injectable } from "@nestjs/common";
import { InjectRepository } from "@nestjs/typeorm";
import { Course } from "src/entity/course.entity";
import { Repository } from "typeorm";
import { Files } from "src/entity/file-descriptor.entity";
import { CourseNotFoundException } from "src/exception/course/course-not-found.exception";
import { FIleMissingException } from "src/exception/file/file-missing.exception";
import * as fs from "fs";
import { DeleteFileDTO } from "src/dto/1.0.0/file/delete-file.dto";
import { QrPdfGenerateDTO } from "src/dto/1.0.0/file/qr-pdf-generate.dto";
import { User } from "src/entity/user.entity";
import { UserCourse } from "src/entity/user-course.entity";
import { UserNotFoundException } from "src/exception/user/user-not-found.exception";
import { CourseType } from "src/entity/course-type.entity";
import { PdfService } from "src/service/1.0.0/pdf.service";
import { v4 } from "uuid";
import merge from "easy-pdf-merge";
import * as path from "path";
import { COURSE_TYPE, FILE_TYPE } from "src/constant/global.constant";
import { FilesCourse } from "src/entity/file-course.entity";
import { CreateFileCheckGlobalDTO } from "src/dto/1.0.0/file/create-file-check-global.dto";
import { FileCourseNotFoundException } from "src/exception/file/file-course-not-found.exception";
import { TagNotUniqueException } from "src/exception/file/tag-no-unique.exception";
import { FileType } from "src/entity/file-type.entity";

import * as pdf from "html-pdf";

@Injectable()
export class FIleService100 {
  constructor(
    @InjectRepository(Course)
    private readonly coursespository: Repository<Course>,
    @InjectRepository(Files)
    private readonly fileRepository: Repository<Files>,
    @InjectRepository(User)
    private readonly userRepository: Repository<User>,
    @InjectRepository(UserCourse)
    private readonly userCourseRepository: Repository<UserCourse>,
    @InjectRepository(CourseType)
    private readonly courseTypeRepository: Repository<CourseType>,
    @InjectRepository(FilesCourse)
    private readonly courseFileRepository: Repository<FilesCourse>,
    @InjectRepository(FileType)
    private readonly fileTypeRepository: Repository<FileType>,

    private readonly pdfService: PdfService
  ) {}

  private async pdfGenerateUser(params: QrPdfGenerateDTO) {
    const user = await this.userRepository.findOne({
      where: { id: params.userId },
    });
    if (!user) {
      throw new UserNotFoundException();
    }
    const course = await this.coursespository.findOne({
      where: { id: params.courseId },
    });
    if (!course) {
      throw new CourseNotFoundException();
    }
    const courseType = await this.courseTypeRepository.findOne({
      where: { id: params.courseTypeId },
    });
    if (!courseType) {
      throw new CourseNotFoundException();
    }
    const userCourse = await this.userCourseRepository.findOne({
      where: { user: user, course: course, courseType: courseType },
    });
    let actUserCourse: UserCourse;
    const description =
      course.description && course.description !== null
        ? course.description
        : "";
    const userName = user.firstName + " " + user.lastName;

    const userGenreatedID = user.generatedID;
    const courseName = course.name;
    const courseTypeName =
      courseType.id === COURSE_TYPE.exam ? "Viszga" : "Gyakorló feladat";
    if (userCourse) {
      if (userCourse.qrCode === params.qrCode && userCourse.pdfName) {
        return userCourse.pdfName;
      } else {
        userCourse.qrCode = params.qrCode;
        userCourse.pdfName = v4();
        await this.userCourseRepository.save(userCourse);
        actUserCourse = await this.userCourseRepository.findOne(userCourse.id);
        await this.pdfService.createPDF(
          "invitation",
          {
            description,
            userName,
            userGenreatedID,
            courseName,
            courseTypeName,
          },
          actUserCourse.pdfName,
          actUserCourse.qrCode
        );
        return actUserCourse.pdfName;
      }
    } else {
      const newUserCourse = this.userCourseRepository.create();
      newUserCourse.qrCode = params.qrCode;
      newUserCourse.user = user;
      newUserCourse.course = course;
      newUserCourse.courseType = courseType;
      newUserCourse.isFinished = false;
      newUserCourse.examSuccessful = false;
      newUserCourse.timeSpent = 0;
      newUserCourse.pdfName = v4();
      await this.userCourseRepository.save(newUserCourse);
      actUserCourse = await this.userCourseRepository.findOne(newUserCourse.id);
      await this.pdfService.createPDF(
        "invitation",
        { description, userName, userGenreatedID, courseName, courseTypeName },
        actUserCourse.pdfName,
        actUserCourse.qrCode
      );
      return actUserCourse.pdfName;
    }
  }

  async uploadFileToCourse(
    courseId: number,
    files: any,
    params: CreateFileCheckGlobalDTO
  ) {
    const course = await this.coursespository.findOne({
      where: { id: courseId },
    });
    if (!course) {
      throw new CourseNotFoundException();
    }
    if (
      !files ||
      !files.file ||
      !files.file[0] ||
      !files.file[0].originalname
    ) {
      throw new FIleMissingException();
    }
    const newFile = this.fileRepository.create();

    newFile.global =
      params.isGlobal.toString() === "true" ||
      params.isGlobal.toString() === "1"
        ? true
        : false;
    newFile.connected = true;
    newFile.fileName = files.file[0].originalname;
    newFile.fileSavedName = files.file[0].filename;
    newFile.fileSavedURL =
      "/files/get-by-filename?filename=" + files.file[0].filename;
    //FILE tipus hozzáadás
    let filetType = undefined;
    if (files.file[0].filename.match(/\.(png|jpg|jpeg|bmp)$/)) {
      filetType = await this.fileTypeRepository.findOne({
        where: { id: FILE_TYPE.picture },
      });
    } else if (files.file[0].filename.match(/\.(mp4)$/)) {
      filetType = await this.fileTypeRepository.findOne({
        where: { id: FILE_TYPE.video },
      });
    } else if (files.file[0].filename.match(/\.(mp3|wav)$/)) {
      filetType = await this.fileTypeRepository.findOne({
        where: { id: FILE_TYPE.sound },
      });
    } else if (files.file[0].filename.match(/\.(fbx|obj|gltf|stl|ply|3mf)$/)) {
      filetType = await this.fileTypeRepository.findOne({
        where: { id: FILE_TYPE._3d },
      });
    } else {
      filetType = await this.fileTypeRepository.findOne({
        where: { id: FILE_TYPE.unknown },
      });
    }
    newFile.fileType = filetType;

    await this.fileRepository.save(newFile);

    const newFileCourse = this.courseFileRepository.create();
    newFileCourse.course = course;
    newFileCourse.file = newFile;
    await this.courseFileRepository.save(newFileCourse);
    const allFileByCourse = await this.courseFileRepository.find({
      where: { course: course },
    });
    let filesSize = 0;
    for (let index = 0; index < allFileByCourse.length; index++) {
      const actualCourseFile = allFileByCourse[index];
      const file = await this.fileRepository.findOne({
        where: { id: actualCourseFile.fileId },
      });
      const stats = fs.statSync("./files/uploadedFiles/" + file.fileSavedName);
      filesSize = filesSize + stats.size;
    }
    const course2 = await this.coursespository.findOne({
      where: { id: courseId },
    });
    course2.dataSize = filesSize / (1024 * 1024);
    await this.coursespository.save(course2);
    return this.fileRepository.findOne(newFile.id);
  }
  async uploadFiles(files: any, tag: string) {
    if (
      !files ||
      !files.file ||
      !files.file[0] ||
      !files.file[0].originalname
    ) {
      throw new FIleMissingException();
    }

    for (let index = 0; index < files.file.length; index++) {
      const element = files.file[index];
      const newFile = this.fileRepository.create();
      newFile.global = true;
      if (tag.trim() !== "") {
        newFile.tag = tag;
        const findedTag = await this.fileRepository.find({
          where: { tag: tag },
        });
        if (findedTag.length > 0) {
          if (fs.existsSync("./files/uploadedFiles/" + element.filename)) {
            try {
              fs.unlinkSync("./files/uploadedFiles/" + element.filename);
            } catch (err) {
              console.error(err);
            }
          }
          throw new TagNotUniqueException();
        }
      }
      newFile.fileName = element.originalname;
      newFile.fileSavedName = element.filename;
      newFile.fileSavedURL =
        "/files/get-by-filename?filename=" + element.filename;

      //FILE tipus hozzáadás
      let filetType = undefined;
      if (element.filename.match(/\.(png|jpg|jpeg|bmp)$/)) {
        filetType = await this.fileTypeRepository.findOne({
          where: { id: FILE_TYPE.picture },
        });
      } else if (element.filename.match(/\.(mp4)$/)) {
        filetType = await this.fileTypeRepository.findOne({
          where: { id: FILE_TYPE.video },
        });
      } else if (element.filename.match(/\.(mp3|wav)$/)) {
        filetType = await this.fileTypeRepository.findOne({
          where: { id: FILE_TYPE.sound },
        });
      } else if (element.filename.match(/\.(fbx|obj|gltf|stl|ply|3mf)$/)) {
        filetType = await this.fileTypeRepository.findOne({
          where: { id: FILE_TYPE._3d },
        });
      } else {
        filetType = await this.fileTypeRepository.findOne({
          where: { id: FILE_TYPE.unknown },
        });
      }
      newFile.fileType = filetType;

      await this.fileRepository.save(newFile);
    }
    return { success: true };
  }

  async getFilesByCourseId(courseId: number) {
    let fileList = [];
    const course = await this.coursespository.findOne({
      where: {
        id: courseId,
      },
    });
    if (!course) {
      throw new CourseNotFoundException();
    }
    const allCourseFiles = await this.courseFileRepository.find({
      where: { course: course },
    });

    for (let index = 0; index < allCourseFiles.length; index++) {
      const element = allCourseFiles[index];
      const actFile = await this.fileRepository.findOne({
        where: { id: element.fileId },
      });
      if (actFile) {
        fileList = [...fileList, actFile];
      }
    }
    return fileList;
  }

  async getAllFiles() {
    const files = await this.fileRepository.find({
      where: { global: true },
    });
    return files;
  }

  async deleteFile(params: DeleteFileDTO) {
    const findedCourse = await this.coursespository.findOne({
      where: { id: params.courseId },
    });
    if (!findedCourse) {
      throw new CourseNotFoundException();
    }

    const foundedFile = await this.fileRepository.findOne({
      where: { fileName: params.fileName, course: findedCourse },
    });
    if (!foundedFile) {
      throw new FIleMissingException();
    }
    //file törlése
    if (fs.existsSync("./files/uploadedFiles/" + foundedFile.fileSavedName)) {
      try {
        fs.unlinkSync("./files/uploadedFiles/" + foundedFile.fileSavedName);
      } catch (err) {
        console.error(err);
      }
    }

    //Object törlése
    await this.fileRepository.delete(foundedFile.id);
    const course2 = await this.coursespository.findOne({
      where: { id: params.courseId },
      relations: ["files"],
    });
    let filesSize = 0;
    // for (let index = 0; index < course2.files.length; index++) {
    //     const actualFile = course2.files[index];

    //     const stats = fs.statSync('./files/uploadedFiles/' + actualFile.fileSavedName)
    //     filesSize = filesSize + stats.size;
    // }
    course2.dataSize = filesSize / (1024 * 1024);
    await this.coursespository.save(course2);

    return { succes: true };
  }
  async deleteFileByFileId(fileId: any) {
    const foundedFile = await this.fileRepository.findOne({
      where: { id: fileId },
    });
    if (!foundedFile) {
      throw new FIleMissingException();
    }
    //file törlése
    if (fs.existsSync("./files/uploadedFiles/" + foundedFile.fileSavedName)) {
      try {
        fs.unlinkSync("./files/uploadedFiles/" + foundedFile.fileSavedName);
      } catch (err) {
        console.error(err);
      }
    }
    //Object törlése
    await this.fileRepository.delete(foundedFile.id);
    return { succes: true };
  }
  async deleteFileByFileIdAndCourseId(fileId: Number, courseId: Number) {
    const file = await this.fileRepository.findOne({ where: { id: fileId } });
    const course = await this.coursespository.findOne({
      where: { id: courseId },
    });
    if (!file) {
      throw new FIleMissingException();
    }
    if (!course) {
      throw new CourseNotFoundException();
    }
    const fileCourse = await this.courseFileRepository.findOne({
      where: { course: course, file: file },
    });
    if (!fileCourse) {
      throw new FileCourseNotFoundException();
    }
    await this.courseFileRepository.delete(fileCourse.id);
    const allCourseFileByFile = await this.courseFileRepository.find({
      where: { file: file },
    });
    if (allCourseFileByFile.length === 0 && file.global === false) {
      //file törlése
      if (fs.existsSync("./files/uploadedFiles/" + file.fileSavedName)) {
        try {
          fs.unlinkSync("./files/uploadedFiles/" + file.fileSavedName);
        } catch (err) {
          console.error(err);
        }
      }
    }
    return { succes: true };
  }
  async genareateAllUserExamPDF(params: any) {
    let pdfRoots = [];
    let pdfNames = [];
    for (let index = 0; index < params.length; index++) {
      const element = params[index];
      const actPdfName = await this.pdfGenerateUser(element);
      pdfRoots = [
        ...pdfRoots,
        path.resolve(__dirname, "../../../files/pdf/" + actPdfName + ".pdf"),
      ];
      pdfNames = [...pdfNames, actPdfName];
    }
    if (pdfRoots.length === 1) {
      return {
        pdfUrl: "/files/get-pdf?filename=" + pdfNames[0] + ".pdf",
      };
    }
    try {
      fs.unlinkSync("./files/pdf/" + params[0].courseId);
    } catch (err) {
      console.error(err);
    }
    await new Promise((resolve, reject) => {
      merge(
        pdfRoots,
        path.resolve(
          __dirname,
          "../../../files/pdf/" + params[0].courseId + ".pdf"
        ),
        function(err, res) {
          if (err) {
            return console.log(err);
          }
          resolve(res);
        }
      );
    });

    return {
      pdfUrl: "/files/get-pdf?filename=" + params[0].courseId + ".pdf",
    };
  }

  async generateAndSavePDF(params: any) {
    const pdName = await this.pdfGenerateUser(params);
    return {
      pdfUrl: "/files/get-pdf?filename=" + pdName + ".pdf",
    };
  }
  async getCoursesByFile(fileId: Number) {
    const courseFiles = await this.courseFileRepository.find({
      where: { fileId: fileId },
      relations: ["course"],
    });
    const courses = courseFiles.map((item) => {
      return item.course;
    });
    return courses;
  }

  async generateCourseDocumentationPDF(id: Number) {
    const findCourse = await this.coursespository.findOne({
      where: { id: id },
    });
    if (!findCourse) {
      throw new CourseNotFoundException();
    }
    const pdfTeszt =
      '<style>img{width: 100%; margin: 0 auto}  table{border-collapse: collapse;    border-spacing: 0; width: 100%; border: 1px double #b3b3b3} tr{border: 1px double #b3b3b3} td{border: 1px double #b3b3b3} .width: 21cm    .min-height: 21cm .text-tiny{ font-size: 11.2px} .text-small{ font-size: 13.6px} .text-big{ font-size: 22.4px} .text-huge{ font-size: 28.8px}</style><div style="word-break: break-all;">' +
      findCourse.documentation +
      "</div>";
    const teszt = await new Promise((resolve, reject) => {
      pdf
        .create(pdfTeszt, { format: "A4" })

        .toFile("./files/pdf/" + findCourse.name + ".pdf", function(err, res) {
          if (err) return console.log("error: " + err);
          console.log(res);

          resolve(res);
        });
    });
    return { pdfUrl: "/files/get-pdf?filename=" + findCourse.name + ".pdf" };
  }

  async generateCourseDocumentationCMS(id: Number) {
    const findCourse = await this.coursespository.findOne({
      where: { id: id },
    });
    if (!findCourse) {
      throw new CourseNotFoundException();
    }
    return { documentation: findCourse.documentation };
  }

  async updateDocumentWithPicture(file, id) {
    const findCourse = await this.coursespository.findOne({
      where: { id: id },
    });
    if (!findCourse) {
      throw new CourseNotFoundException();
    }
    if (!file || !file.file || !file.file[0] || !file.file[0].originalname) {
      throw new FIleMissingException();
    }
    const url =
      process.env.BASE_URL +
      "1.0.0/files/get-by-filename?filename=" +
      file.file[0].filename;
    const imgTag = '<figure class="image"><img src=' + url + "></figure>";
    findCourse.documentation = findCourse.documentation + imgTag;
    await this.coursespository.save(findCourse);
  }
}

result-matching ""

    No results matching ""