src/service/1.0.0/file-descriptor.service.ts
Methods |
|
constructor(coursespository: Repository
|
|||||||||||||||||||||||||||
Parameters :
|
Async deleteFile | ||||||
deleteFile(params: DeleteFileDTO)
|
||||||
Parameters :
Returns :
{}
|
Async deleteFileByFileId | ||||||
deleteFileByFileId(fileId: any)
|
||||||
Parameters :
Returns :
{}
|
Async deleteFileByFileIdAndCourseId |
deleteFileByFileIdAndCourseId(fileId: Number, courseId: Number)
|
Returns :
{}
|
Async genareateAllUserExamPDF | ||||||
genareateAllUserExamPDF(params: any)
|
||||||
Parameters :
Returns :
{}
|
Async generateAndSavePDF | ||||||
generateAndSavePDF(params: any)
|
||||||
Parameters :
Returns :
{}
|
Async generateCourseDocumentationCMS | ||||||
generateCourseDocumentationCMS(id: Number)
|
||||||
Parameters :
Returns :
{}
|
Async generateCourseDocumentationPDF | ||||||
generateCourseDocumentationPDF(id: Number)
|
||||||
Parameters :
Returns :
{}
|
Async getAllFiles |
getAllFiles()
|
Returns :
{}
|
Async getCoursesByFile | ||||||
getCoursesByFile(fileId: Number)
|
||||||
Parameters :
Returns :
{}
|
Async getFilesByCourseId | ||||||
getFilesByCourseId(courseId: number)
|
||||||
Parameters :
Returns :
{}
|
Private Async pdfGenerateUser | ||||||
pdfGenerateUser(params: QrPdfGenerateDTO)
|
||||||
Parameters :
Returns :
{}
|
Async updateDocumentWithPicture | ||||||
updateDocumentWithPicture(file, id)
|
||||||
Parameters :
Returns :
any
|
Async uploadFiles |
uploadFiles(files: any, tag: string)
|
Returns :
{}
|
Async uploadFileToCourse | ||||||||||||
uploadFileToCourse(courseId: number, files: any, params: CreateFileCheckGlobalDTO)
|
||||||||||||
Parameters :
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);
}
}