File

src/service/1.0.0/course.service.ts

Index

Methods

Constructor

constructor(coursespository: Repository, userRepository: Repository, fileRepository: Repository, userCourseRepository: Repository, courseTypeRepository: Repository, fileCoureRepository: Repository, languageRepository: Repository, courseSatusRepository: Repository, globalService: GlobalService100)
Parameters :
Name Type Optional
coursespository Repository<Course> No
userRepository Repository<User> No
fileRepository Repository<Files> No
userCourseRepository Repository<UserCourse> No
courseTypeRepository Repository<CourseType> No
fileCoureRepository Repository<FilesCourse> No
languageRepository Repository<Language> No
courseSatusRepository Repository<CourseStatus> No
globalService GlobalService100 No

Methods

Async addUsersToCourse
addUsersToCourse(params: AddUsersToCourseDTO)
Parameters :
Name Type Optional
params AddUsersToCourseDTO No
Returns : {}
Async createCourse
createCourse(user: User, param: CreateCourseDTO)
Parameters :
Name Type Optional
user User No
param CreateCourseDTO No
Returns : {}
Async createQualityCourse
createQualityCourse(user: User, param: CreateCourseDTO)
Parameters :
Name Type Optional
user User No
param CreateCourseDTO No
Returns : {}
Async deleteCourseByID
deleteCourseByID(id: number)
Parameters :
Name Type Optional
id number No
Returns : {}
Async documentationEdit
documentationEdit(params)
Parameters :
Name Optional
params No
Returns : {}
Async duplicateCourse
duplicateCourse(user: User, id: number)
Parameters :
Name Type Optional
user User No
id number No
Returns : {}
Async editCourseBaseDataFromCMS
editCourseBaseDataFromCMS(params: EditCourseFromCMSDTO)
Parameters :
Name Type Optional
params EditCourseFromCMSDTO No
Returns : {}
Async getCourseByIdToCMS
getCourseByIdToCMS(user: User, curseId)
Parameters :
Name Type Optional
user User No
curseId No
Returns : {}
Async getCourses
getCourses(user: User)
Parameters :
Name Type Optional
user User No
Returns : {}
Async getCoursesByCurseId
getCoursesByCurseId(user: User, courseId)
Parameters :
Name Type Optional
user User No
courseId No
Returns : {}
Async getCoursesCMS
getCoursesCMS(user: User)
Parameters :
Name Type Optional
user User No
Returns : {}
Async getQualityCourses
getQualityCourses(user: User)
Parameters :
Name Type Optional
user User No
Returns : {}
Async getQualityCoursesCMS
getQualityCoursesCMS(user: User)
Parameters :
Name Type Optional
user User No
Returns : {}
Async saveCourse
saveCourse(user: User, params: SaveCourseDTO)
Parameters :
Name Type Optional
user User No
params SaveCourseDTO No
Returns : {}
Async setCourseActiveOrDeactive
setCourseActiveOrDeactive(params: SetCourseIsActiveDTO)
Parameters :
Name Type Optional
params SetCourseIsActiveDTO No
Returns : {}
Async setFileToCourse
setFileToCourse(params: SetFileToCourseDTO)
Parameters :
Name Type Optional
params SetFileToCourseDTO No
Returns : {}
Async setUsersToCourse
setUsersToCourse(params: any)
Parameters :
Name Type Optional
params any No
Returns : {}
Async xApiteszt
xApiteszt()
Returns : any
import { Injectable } from "@nestjs/common";
import { InjectRepository } from "@nestjs/typeorm";
import { Course } from "src/entity/course.entity";
import { Repository } from "typeorm";
import { CreateCourseDTO } from "src/dto/1.0.0/course/create-course.dto";
import { User } from "src/entity/user.entity";
import { SaveCourseDTO } from "src/dto/1.0.0/course/save-course.dto";
import { CourseNotFoundException } from "src/exception/course/course-not-found.exception";
import { AddUsersToCourseDTO } from "src/dto/1.0.0/course/add-users-to-course.dto";
import { EmptyUserArrayException } from "src/exception/course/empty-user-array.exception";
import { Files } from "src/entity/file-descriptor.entity";
import { ROLES } from "src/constant/roles.contant";
import { STATUS } from "src/constant/global.constant";
import * as fs from "fs";
import { UserCourse } from "src/entity/user-course.entity";
import { COURSE_TYPE, LANGUAGE } from "src/constant/global.constant";
import { EditCourseFromCMSDTO } from "src/dto/1.0.0/course/edit-course-from-cms.dto";
import { CourseType } from "src/entity/course-type.entity";
import { FilesCourse } from "src/entity/file-course.entity";
import { SetFileToCourseDTO } from "src/dto/1.0.0/file/set-file-to-course.dto";
import { FIleMissingException } from "src/exception/file/file-missing.exception";
import { GlobalService100 } from "./global.service";
import { Language } from "src/entity/language.entity";
import { NotFoundLanguageException } from "src/exception/language/not-found.language.exception";
import { SetCourseIsActiveDTO } from "src/dto/1.0.0/course/set-course-is-active.dto";
import { CourseStatus } from "src/entity/course-status.entity";
var adl = require("adl-xapiwrapper");
@Injectable()
export class CoursesService100 {
  constructor(
    @InjectRepository(Course)
    private readonly coursespository: Repository<Course>,
    @InjectRepository(User)
    private readonly userRepository: Repository<User>,
    @InjectRepository(Files)
    private readonly fileRepository: Repository<Files>,
    @InjectRepository(UserCourse)
    private readonly userCourseRepository: Repository<UserCourse>,
    @InjectRepository(CourseType)
    private readonly courseTypeRepository: Repository<CourseType>,
    @InjectRepository(FilesCourse)
    private readonly fileCoureRepository: Repository<FilesCourse>,
    @InjectRepository(Language)
    private readonly languageRepository: Repository<Language>,
    @InjectRepository(CourseStatus)
    private readonly courseSatusRepository: Repository<CourseStatus>,
    private readonly globalService: GlobalService100
  ) {}

  async createCourse(user: User, param: CreateCourseDTO) {
    const language = await this.languageRepository.findOne({
      where: { id: LANGUAGE.hu },
    });
    const editableStatus = await this.courseSatusRepository.findOne({
      where: { id: STATUS.editable },
    });
    const newCurse = this.coursespository.create();
    newCurse.courseStatus = editableStatus;
    newCurse.name = param.name;
    newCurse.description = param.desription ? param.desription : null;
    newCurse.language = language;
    newCurse.isQuality = false;
    await this.coursespository.save(newCurse);
    //kurzus adminokhoz adása
    const admins = await this.userRepository.find({
      where: { groupId: ROLES.admin },
      relations: ["courses"],
    });
    for (let index = 0; index < admins.length; index++) {
      const actualAdmin = admins[index];
      actualAdmin.courses = [...actualAdmin.courses, newCurse];
      await this.userRepository.save(actualAdmin);
    }
    //maintainer hozzáadása
    const findedUser = await this.userRepository.findOne({
      where: { id: user.id },
      relations: ["courses"],
    });
    if (findedUser && findedUser.groupId === ROLES.maintainer) {
      findedUser.courses = [...findedUser.courses, newCurse];
      await this.userRepository.save(findedUser);
    }
    return await this.globalService.updateCourseDataSize(newCurse.id);
  }
  async createQualityCourse(user: User, param: CreateCourseDTO) {
    const editableStatus = await this.courseSatusRepository.findOne({
      where: { id: STATUS.editable },
    });
    const language = await this.languageRepository.findOne({
      where: { id: LANGUAGE.hu },
    });
    const newCurse = this.coursespository.create();
    newCurse.courseStatus = editableStatus;
    newCurse.name = param.name;
    newCurse.language = language;
    newCurse.description = param.desription ? param.desription : null;
    newCurse.isQuality = true;
    await this.coursespository.save(newCurse);
    //kurzus adminokhoz adása
    const admins = await this.userRepository.find({
      where: { groupId: ROLES.admin },
      relations: ["courses"],
    });
    for (let index = 0; index < admins.length; index++) {
      const actualAdmin = admins[index];
      actualAdmin.courses = [...actualAdmin.courses, newCurse];
      await this.userRepository.save(actualAdmin);
    }
    //maintainer hozzáadása
    const findedUser = await this.userRepository.findOne({
      where: { id: user.id },
      relations: ["courses"],
    });
    if (findedUser && findedUser.groupId === ROLES.maintainer) {
      findedUser.courses = [...findedUser.courses, newCurse];
      await this.userRepository.save(findedUser);
    }
    return await this.globalService.updateCourseDataSize(newCurse.id);
  }

  async getCoursesCMS(user: User) {
    const findedUser = await this.userRepository.findOne({
      where: { id: user.id },
      relations: ["courses", "courses.language", "courses.courseStatus"],
    });
    // console.log(findedUser.courses);
    const filtered = findedUser.courses.filter(
      (item) => item.isQuality === false
    );

    return filtered;
  }
  async getQualityCoursesCMS(user: User) {
    const findedUser = await this.userRepository.findOne({
      where: { id: user.id },
      relations: ["courses", "courses.language", "courses.courseStatus"],
    });
    // console.log(findedUser.courses);
    const filtered = findedUser.courses.filter(
      (item) => item.isQuality === true
    );

    return filtered;
  }

  async getCourses(user: User) {
    const findedUser = await this.userRepository.findOne({
      where: { id: user.id },
      relations: [
        "courses",
        "group",
        "courses.language",
        "courses.courseStatus",
      ],
    });
    let courses = [];
    if (findedUser.groupId === 1 || findedUser.groupId === 2) {
      const allCourse = await this.coursespository.find({
        where: { isQuality: false },
      });
      const allCourseFile = await this.fileCoureRepository.find();
      for (let index = 0; index < allCourse.length; index++) {
        const element = allCourse[index];
        const actualFilteredCourseFiles = allCourseFile.filter(
          (item) => item.courseId === element.id
        );
        let courseToReturn: any = Object.assign({}, element);
        courseToReturn.files = [];

        for (let index = 0; index < actualFilteredCourseFiles.length; index++) {
          const actFilteredFiles = actualFilteredCourseFiles[index];
          const file = await this.fileRepository.findOne({
            where: { id: actFilteredFiles.fileId },
          });
          courseToReturn.files = [...courseToReturn.files, file];
        }
        courses = [...courses, courseToReturn];
      }
    } else {
      const allUserCourse = await this.userCourseRepository.find({
        where: { user: findedUser },
        relations: ["course", "course.language", "course.courseStatus"],
      });

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

        let courseToReturn: any = Object.assign({}, element.course);
        courseToReturn.type = element.courseTypeId;
        if (element.course.isQuality === false) {
          courses = [...courses, courseToReturn];
        }
      }
    }

    return courses;
  }

  async getQualityCourses(user: User) {
    const findedUser = await this.userRepository.findOne({
      where: { id: user.id },
      relations: [
        "courses",
        "group",
        "courses.language",
        "courses.courseStatus",
      ],
    });
    let courses = [];
    if (findedUser.groupId === 1 || findedUser.groupId === 2) {
      const allCourse = await this.coursespository.find({
        where: { isQuality: true },
      });
      const allCourseFile = await this.fileCoureRepository.find();
      for (let index = 0; index < allCourse.length; index++) {
        const element = allCourse[index];
        const actualFilteredCourseFiles = allCourseFile.filter(
          (item) => item.courseId === element.id
        );
        let courseToReturn: any = Object.assign({}, element);
        courseToReturn.files = [];

        for (let index = 0; index < actualFilteredCourseFiles.length; index++) {
          const actFilteredFiles = actualFilteredCourseFiles[index];
          const file = await this.fileRepository.findOne({
            where: { id: actFilteredFiles.fileId },
          });
          courseToReturn.files = [...courseToReturn.files, file];
        }
        courses = [...courses, courseToReturn];
      }
    } else {
      const allUserCourse = await this.userCourseRepository.find({
        where: { user: findedUser },
        relations: ["course", "course.language", "course.courseStatus"],
      });

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

        let courseToReturn: any = Object.assign({}, element.course);
        courseToReturn.type = element.courseTypeId;
        if (element.course.isQuality === true) {
          courses = [...courses, courseToReturn];
        }
      }
    }

    return courses;
  }

  async getCoursesByCurseId(user: User, courseId) {
    // const findedUser = await this.userRepository.findOne({
    //   where: { id: user.id },
    //   relations: ["courses", "courses.language",  "courses.courseStatus"],
    // });
    // let findedCurse = [];

    // if (findedUser.courses.length > 0)
    //   findedCurse = findedUser.courses.filter((curse) => {
    //     return curse.id === parseInt(curseId);
    //   });
    let courses = [];

    const allCourse = await this.coursespository.find({
      where: { id: courseId },
    });
    const allCourseFile = await this.fileCoureRepository.find();
    for (let index = 0; index < allCourse.length; index++) {
      const element = allCourse[index];
      const actualFilteredCourseFiles = allCourseFile.filter(
        (item) => item.courseId === element.id
      );
      let courseToReturn: any = Object.assign({}, element);
      courseToReturn.files = [];

      for (let index = 0; index < actualFilteredCourseFiles.length; index++) {
        const actFilteredFiles = actualFilteredCourseFiles[index];
        const file = await this.fileRepository.findOne({
          where: { id: actFilteredFiles.fileId },
        });
        courseToReturn.files = [...courseToReturn.files, file];
      }
      courses = [...courses, courseToReturn];
    }
    return courses && courses[0] !== undefined ? courses[0] : {};
  }

  async getCourseByIdToCMS(user: User, curseId) {
    const findedUser = await this.userRepository.findOne({
      where: { id: user.id },
      relations: ["courses", "courses.language", "courses.courseStatus"],
    });
    let findedCurse = [];
    if (findedUser.courses.length > 0)
      findedCurse = findedUser.courses.filter((curse) => {
        return curse.id === parseInt(curseId);
      });
    const userCourse = await this.userCourseRepository.find({
      where: {
        courseId: curseId,
        isActive: true,
        courseTypeId: COURSE_TYPE.practice,
      },
      relations: ["user", "user.group"],
    });
    const userCourseExamFinished = await this.userCourseRepository.find({
      where: {
        courseId: curseId,
        isActive: true,
        courseTypeId: COURSE_TYPE.exam,
        examSuccessful: true,
      },
      relations: ["user", "user.group"],
    });
    const userCourseExamNotFinished = await this.userCourseRepository.find({
      where: {
        courseId: curseId,
        isActive: true,
        courseTypeId: COURSE_TYPE.exam,
        examSuccessful: false,
      },
      relations: ["user", "user.group"],
    });
    const filtered = userCourse.filter(
      (item) => item.user.group.id === ROLES.user
    );
    const filteredExamFinished = userCourseExamFinished.filter(
      (item) => item.user.group.id === ROLES.user
    );
    const filteredExamNotfinished = userCourseExamNotFinished.filter(
      (item) => item.user.group.id === ROLES.user
    );
    return {
      course: findedCurse[0],
      studentNumber: filtered.length,
      successfullExamStudentNumber: filteredExamFinished.length,
      notSuccessfullExamStudentNumber: filteredExamNotfinished.length,
    };
  }

  async saveCourse(user: User, params: SaveCourseDTO) {
    const findedCurse = await this.coursespository.findOne({
      where: { id: params.courseId },
    });
    if (!findedCurse) {
      throw new CourseNotFoundException();
    }

    findedCurse.data = params.data;

    await this.coursespository.save(findedCurse);
    await this.globalService.updateCourseDataSize(findedCurse.id);
    const findedUser = await this.userRepository.findOne({
      where: { id: user.id },
      relations: ["courses", "courses.language"],
    });
    findedUser.courses = [...findedUser.courses, findedCurse];
    await this.userRepository.save(findedUser);
    return await this.coursespository.findOne(findedCurse.id);
  }

  async addUsersToCourse(params: AddUsersToCourseDTO) {
    const findedCurse = await this.coursespository.findOne({
      where: { id: params.courseId },
    });
    if (!findedCurse) {
      throw new CourseNotFoundException();
    }
    if (params.userIds && params.userIds[0]) {
      const findedUser = await this.userRepository.findByIds(params.userIds, {
        relations: ["courses", "courses.language"],
      });
      await Promise.all(
        findedUser.map(async (user) => {
          user.courses = [...user.courses, findedCurse];
          await this.userRepository.save(user);
        })
      );
    } else {
      throw new EmptyUserArrayException();
    }
    return {
      success: true,
    };
  }

  async deleteCourseByID(id: number) {
    //kurzus kikeresése
    const findedCourse = await this.coursespository.findOne({
      where: { id: id },
    });

    if (!findedCourse) {
      throw new CourseNotFoundException();
    }

    // await Promise.all(
    //   findedCourse.files.map(async (file) => {
    //     const actualFile = await this.fileRepository.findOne({
    //       where: { id: file.id },
    //     });
    //     try {
    //       fs.unlinkSync("./files/uploadedFiles/" + file.fileSavedName);
    //     } catch (err) {
    //       console.error(err);
    //     }
    //     await this.fileRepository.delete(actualFile.id);
    //   })
    // );
    await this.coursespository.delete(findedCourse.id);
    return findedCourse;
  }
  async editCourseBaseDataFromCMS(params: EditCourseFromCMSDTO) {
    const course = await this.coursespository.findOne({
      where: { id: params.courseId },
    });
    if (!course) {
      throw new CourseNotFoundException();
    }
    const language = await this.languageRepository.findOne({
      where: { id: params.languageId },
    });
    const status = await this.courseSatusRepository.findOne({
      where: { id: params.statusId },
    });
    if (!language) {
      throw new NotFoundLanguageException();
    }
    course.name = params.name;
    course.language = language;
    course.courseStatus = status;
    course.description = params.description ? params.description : null;
    await this.coursespository.save(course);
    return {
      success: true,
    };
  }

  async setUsersToCourse(params: any) {
    const course = await this.coursespository.findOne({
      where: { id: params.courseId },
    });
    if (!course) {
      throw new CourseNotFoundException();
    }
    let ids = [];
    const courseType = await this.courseTypeRepository.findOne({
      where: { id: params.courseTypeId },
    });
    if (params.users.length > 0) {
      for (let index = 0; index < params.users.length; index++) {
        const element = params.users[index];
        ids = [...ids, element.userId];
        const actUser = await this.userRepository.findOne({
          where: { id: element.userId },
        });

        const findUserCourse = await this.userCourseRepository.findOne({
          where: { course: course, user: actUser, courseType: courseType },
        });
        // hozzáadni ha még nincs hozzárandelve
        if (!findUserCourse) {
          const newUserCourse = this.userCourseRepository.create();
          newUserCourse.course = course;
          newUserCourse.user = actUser;
          newUserCourse.examSuccessful = false;
          newUserCourse.courseType = courseType;
          newUserCourse.qrCode = element.qr;
          newUserCourse.isActive = true;
          newUserCourse.isFinished = false;
          newUserCourse.examSuccessful = false;
          await this.userCourseRepository.save(newUserCourse);
        } else if (findUserCourse && findUserCourse.isActive == false) {
          findUserCourse.isActive = true;
          await this.userCourseRepository.save(findUserCourse);
        }
        // kivenni ha már nem létezik (isActive set false)
        const allUserCourse = await this.userCourseRepository.find({
          where: { course: course, courseType: courseType, isActive: true },
        });
        const allUserCourseWithoutActualUserList = allUserCourse.filter(
          (item) => !ids.includes(item.userId)
        );
        for (
          let index = 0;
          index < allUserCourseWithoutActualUserList.length;
          index++
        ) {
          const element = allUserCourseWithoutActualUserList[index];
          const deactiveUserCourse = await this.userCourseRepository.findOne(
            element.id
          );
          deactiveUserCourse.isActive = false;
          await this.userCourseRepository.save(deactiveUserCourse);
        }
      }
    } else {
      const allUserCourse = await this.userCourseRepository.find({
        where: { course: course, courseType: courseType, isActive: true },
      });
      for (let index = 0; index < allUserCourse.length; index++) {
        const element = allUserCourse[index];
        const deactiveUserCourse = await this.userCourseRepository.findOne(
          element.id
        );
        deactiveUserCourse.isActive = false;
        await this.userCourseRepository.save(deactiveUserCourse);
      }
    }
    return {
      success: true,
    };
  }

  async duplicateCourse(user: User, id: number) {
    const parentCourse = await this.coursespository.findOne({
      where: { id: id },
      relations: ["userCourse", "fileCourse", "fileCourse.file", "language"],
    });
    if (!parentCourse) {
      throw new CourseNotFoundException();
    }
    const status = await this.courseSatusRepository.findOne({
      where: { id: STATUS.editable },
    });
    const newCourse = await this.coursespository.create();
    newCourse.name = parentCourse.name + "_másolat";
    newCourse.data = parentCourse.data;
    newCourse.description = parentCourse.description;
    newCourse.language = parentCourse.language;
    newCourse.dataSize = parentCourse.dataSize;
    newCourse.isQuality = parentCourse.isQuality;
    newCourse.courseStatus = status;
    (newCourse.language = parentCourse.language),
      (newCourse.description = parentCourse.description);

    await this.coursespository.save(newCourse);
    //kurzus adminokhoz adása
    const admins = await this.userRepository.find({
      where: { groupId: ROLES.admin },
      relations: ["courses"],
    });
    for (let index = 0; index < admins.length; index++) {
      const actualAdmin = admins[index];
      actualAdmin.courses = [...actualAdmin.courses, newCourse];
      await this.userRepository.save(actualAdmin);
    }
    //maintainer hozzáadása
    const findedUser = await this.userRepository.findOne({
      where: { id: user.id },
      relations: ["courses"],
    });
    if (findedUser && findedUser.groupId === ROLES.maintainer) {
      findedUser.courses = [...findedUser.courses, newCourse];
      await this.userRepository.save(findedUser);
    }

    //FILE-ok kikeresése és hozzáadása a másolathoz.
    const allCourseFile = await this.fileCoureRepository.find({
      where: { course: parentCourse },
      relations: ["file"],
    });
    for (let index = 0; index < allCourseFile.length; index++) {
      const element = allCourseFile[index];
      const actFile = await this.fileRepository.findOne({
        where: { id: element.fileId },
      });
      const registerFileToCourse = this.fileCoureRepository.create();
      registerFileToCourse.course = newCourse;
      registerFileToCourse.file = actFile;
      await this.fileCoureRepository.save(registerFileToCourse);
    }
    return parentCourse;
  }

  async setFileToCourse(params: SetFileToCourseDTO) {
    const course = await this.coursespository.findOne({
      where: {
        id: params.courseId,
      },
    });
    if (!course) {
      throw new CourseNotFoundException();
    }
    let fileList = [];
    for (let index = 0; index < params.fileIds.length; index++) {
      const element = params.fileIds[index];
      const file = await this.fileRepository.findOne({
        where: { id: element },
      });
      if (!file) {
        throw new FIleMissingException();
      }

      fileList = [...fileList, file];
    }
    for (let index = 0; index < fileList.length; index++) {
      const element = fileList[index];
      const courseFile = await this.fileCoureRepository.findOne({
        where: { course: course, file: element },
      });
      if (!courseFile) {
        let file = await this.fileRepository.findOne({
          where: { id: element.id },
        });
        file.connected = true;
        file = await this.fileRepository.save(file);
        const newCourseFile = this.fileCoureRepository.create();
        newCourseFile.course = course;
        newCourseFile.file = file;
        await this.fileCoureRepository.save(newCourseFile);
      }
    }
    return this.globalService.updateCourseDataSize(course.id);
  }

  async setCourseActiveOrDeactive(params: SetCourseIsActiveDTO) {
    const course = await this.coursespository.findOne({
      where: { id: params.courseId },
    });
    if (!course) {
      throw new CourseNotFoundException();
    }
    course.isActive = params.isActive;
    await this.coursespository.save(course);

    return {
      success: true,
    };
  }
  async documentationEdit(params) {
    const course = await this.coursespository.findOne({
      where: { id: params.id },
    });
    if (!course) {
      throw new CourseNotFoundException();
    }
    course.documentation = params.documentation;
    await this.coursespository.save(course);

    return {
      success: true,
    };
  }
  async xApiteszt() {
    var opts = {
      url: "https://cloud.scorm.com/lrs/I8473VAWTI/",
      auth: {
        user: "I8473VAWTI",
        pass: "xMrefr1k2o3KWN6ipiAE34HkTEWep4VT8nw6TKZv",
      },
    };

    var mylrs = new adl.XAPIWrapper(opts);

    var stmt = {
      actor: { mbox: "mailto:martonka.peter@appentum.hu" },
      verb: {
        id: "http://adlnet.gov/expapi/verbs/answered",
        display: { "en-US": "answered" },
      },
      object: { id: "http://adlnet.gov/expapi/activities/question" },
    };

    mylrs.sendStatements(stmt, function(err, resp, bdy) {
      adl.log("info", resp.statusCode);
      adl.log("info", bdy);
    });

    mylrs.getStatements(null, null, function(err, resp, bdy) {
      console.log(resp.statusCode);
      console.log(JSON.parse(bdy));
    });
  }
}

result-matching ""

    No results matching ""