Symfony Profiler

<?php
namespace EADPlataforma\Controller\Admin;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Cache;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Routing\Annotation\Route;
use EADPlataforma\Entity\Course;
use EADPlataforma\Entity\CourseTeam;
use EADPlataforma\Entity\Category;
use EADPlataforma\Entity\Product;
use EADPlataforma\Entity\ProductOffer;
use EADPlataforma\Entity\ProductTeam;
use EADPlataforma\Entity\Lesson;
use EADPlataforma\Entity\CourseCertificateTemplate;
use EADPlataforma\Entity\Enrollment;
use EADPlataforma\Entity\Exam;
use EADPlataforma\Entity\User;
use EADPlataforma\Entity\UserSubscription;
use EADPlataforma\Enum\CourseEnum;
use EADPlataforma\Enum\CourseTeamEnum;
use EADPlataforma\Enum\ProductEnum;
use EADPlataforma\Enum\EnrollmentEnum;
use EADPlataforma\Enum\ExamEnum;
use EADPlataforma\Enum\ErrorEnum;
use EADPlataforma\Util\StringUtil;
/**
* @Route(
* path = "/admin/course",
* schemes = {"http|https"}
* )
* @Cache(
* maxage = "0",
* smaxage = "0",
* expires = "now",
* public = false
* )
*/
class CourseController extends AbstractController {
public function getEntityClass(){
return Course::class;
}
/**
* @Route(
* path = "/list/paginate/",
* methods = {"GET"},
* )
*/
public function getCoursePaginate(Request $request) {
$permission = $this->userPermissionUtil->getPermission("course", "see");
if($this->userPermissionUtil->isLow($permission)){
return $this->eadResponse(null, ErrorEnum::PERMISSION);
}
$this->requestUtil->setRequest($request)->setData();
$userClass = User::class;
$categoryClass = Category::class;
$courseTeamClass = CourseTeam::class;
$productClass = Product::class;
$enrollmentClass = Enrollment::class;
$userOnId = $this->user->getId();
$columns = [
"c.id",
"c.title",
"c.order",
"c.status",
"c.free",
"c.workload",
"cc.id AS categoryId",
"cc.category",
"u.name",
"u.photo",
"u.email",
"u.id AS userId",
];
$columnNotUseInFilter = [
"(CASE WHEN c.id IN (
SELECT
IDENTITY(ct.course)
FROM {$courseTeamClass} AS ct
WHERE ct.deleted = 0
AND ct.user = {$userOnId}
) THEN 1 ELSE 0 END ) AS isInTeam "
];
$joins = [
"{$userClass} AS u" => "u.id = c.user",
"{$categoryClass} AS cc" => "cc.id = c.category "
];
$productId = (int)$this->requestUtil->getField('product');
if($productId > 0){
$joins["{$productClass} AS p"] = " c MEMBER OF p.course
AND p.deleted = 0
AND p.id = {$productId} ";
}
$productIdNotInclude = (int)$this->requestUtil->getField('productNotInclude');
if($productIdNotInclude > 0){
$joins["{$productClass} AS p"] = " c NOT MEMBER OF p.course
AND p.deleted = 0
AND p.id = {$productIdNotInclude} ";
}
$onlyCertificate = (int)$this->requestUtil->getField('onlyCertificate');
$categoryId = (int)$this->requestUtil->getField('category');
$status = $this->requestUtil->getField('status');
$userId = (int)$this->requestUtil->getField('user');
$enrollment = (int)$this->requestUtil->getField('enrollment');
$orderParam = $this->requestUtil->getField('order');
$searchText = $this->requestUtil->getField('searchText');
$limit = $this->requestUtil->getField('limit');
$offset = $this->requestUtil->getField('offset');
$free = $this->requestUtil->getField('free');
$filter = [];
$filterDelete = $this->requestUtil->getDeletedParam();
$filter["whereText"] = " c.id > 0 ";
if($this->userPermissionUtil->isMiddle($permission)){
$filter["whereText"] .= " AND c.id IN (
SELECT
IDENTITY(cTeam.course)
FROM {$courseTeamClass} AS cTeam
WHERE cTeam.deleted = 0
AND cTeam.user = {$userOnId}
) ";
}
if($enrollment == CourseEnum::YES){
$filter["whereText"] .= " AND c.id IN (
SELECT
IDENTITY(e.course)
FROM {$enrollmentClass} AS e
WHERE e.deleted = 0
) ";
}
if(!empty($onlyCertificate)){
$filter["whereText"] .= " AND c.courseCertificateTemplate IS NOT NULL ";
}
if($categoryId > 0){
$filter["c.category"] = $categoryId;
}
if (!is_null($free)) {
$filter["c.free"] = $free;
}
if(!is_null($status)){
if($status == CourseEnum::FREE){
$yes = CourseEnum::YES;
$statusPubli = CourseEnum::PUBLISHED;
$filter["whereText"] .= "
AND c.free = {$yes} AND c.status = {$statusPubli}
";
}else if($status == CourseEnum::PUBLISHED){
$no = CourseEnum::NO;
$filter["whereText"] .= "
AND c.free = {$no} AND c.status = {$status}
";
}else{
$filter["c.status"] = $status;
}
}
if($userId > 0){
$filter["c.user"] = $userId;
}
$order = ["c.order" => "ASC"];
if(!empty($orderParam)){
$order = json_decode($orderParam, true);
}
$data = $this->repository->paginate(
"c",
$searchText,
$columns,
$joins,
$filter,
$order,
$limit,
$offset,
$filterDelete,
false,
$columnNotUseInFilter
);
$examRepository = $this->em->getRepository(Exam::class);
foreach ($data["rows"] as $key => $item) {
$item = (object)$item;
$item->title = StringUtil::fromUnicode($item->title);
if($item->status == CourseEnum::PUBLISHED && $item->free == CourseEnum::YES){
$item->status = CourseEnum::FREE;
}
/*$item->hasQuiz = $examRepository->count([
"deleted" => ExamEnum::ITEM_NO_DELETED,
"type" => ExamEnum::QUIZ,
"course" => $item->id,
]);*/
$item->hasExam = $examRepository->count([
"deleted" => ExamEnum::ITEM_NO_DELETED,
"type" => ExamEnum::COURSE,
"status" => ExamEnum::PUBLISHED,
"course" => $item->id,
]);
$data["rows"][$key] = $item;
}
return $this->eadResponse($data);
}
/**
* @Route(
* path = "/list/paginate/all",
* methods = {"GET"},
* )
*/
public function getCoursePaginateAll(Request $request) {
$permission = $this->userPermissionUtil->getPermission("course", "see");
$this->requestUtil->setRequest($request)->setData();
$columns = [
"c.id",
"c.title",
"c.order",
"c.status",
"c.free",
"c.workload",
"cc.id AS categoryId",
"cc.category",
"u.name",
"u.photo",
"u.email",
"u.id AS userId",
"DATE_FORMAT(c.dateDelete, '%Y-%m-%d %H:%i:%s') AS dateDelete",
"ud.name AS userDelete"
];
$userClass = User::class;
$categoryClass = Category::class;
$courseTeamClass = CourseTeam::class;
$productClass = Product::class;
$joins = [
"{$userClass} AS u" => "u.id = c.user",
"{$categoryClass} AS cc" => "cc.id = c.category",
"{$userClass} AS ud" => ["LEFT", "ud.id = c.userDelete "]
];
$productId = (int)$this->requestUtil->getField('product');
if($productId > 0){
$joins["{$productClass} AS p"] = " c MEMBER OF p.course
AND p.deleted = 0
AND p.id = {$productId} ";
}
$productIdNotInclude = (int)$this->requestUtil->getField('productNotInclude');
if($productIdNotInclude > 0){
$joins["{$productClass} AS p"] = " c NOT MEMBER OF p.course
AND p.deleted = 0
AND p.id = {$productIdNotInclude} ";
}
$onlyCertificate = (int)$this->requestUtil->getField('onlyCertificate');
$categoryId = (int)$this->requestUtil->getField('category');
$status = $this->requestUtil->getField('status');
$userId = (int)$this->requestUtil->getField('user');
$certificate = $this->requestUtil->getField('certificate');
$productType = (int)$this->requestUtil->getField('productType');
$orderParam = $this->requestUtil->getField('order');
$searchText = $this->requestUtil->getField('searchText');
$limit = $this->requestUtil->getField('limit');
$offset = $this->requestUtil->getField('offset');
$filter = [];
$filterDelete = $this->requestUtil->getDeletedParam();
$filter["whereText"] = " c.id > 0 ";
if($this->userPermissionUtil->isMiddle($permission)){
$userOnId = $this->user->getId();
$filter["whereText"] .= " AND c.id IN (
SELECT
IDENTITY(ct.course)
FROM {$courseTeamClass} AS ct
WHERE ct.deleted = 0
AND ct.user = {$userOnId}
) ";
}
if(!empty($onlyCertificate)){
$filter["whereText"] .= " c.courseCertificateTemplate IS NOT NULL ";
}
if($categoryId > 0){
$filter["c.category"] = $categoryId;
}
if(!is_null($status)){
$filter["c.status"] = $status;
}
if($certificate == CourseEnum::YES){
$filter["c.certificate"] = CourseEnum::YES;
}
if($productType == ProductEnum::CERTIFICATE){
$no = ProductEnum::NO;
$filter["whereText"] .= " AND {$no} = (
SELECT
COUNT(pCert.id)
FROM {$productClass} AS pCert
WHERE pCert.deleted = 0
AND c MEMBER OF pCert.course
) ";
}
if($userId > 0){
$filter["c.user"] = $userId;
}
$order = ["c.order" => "ASC"];
if(!empty($orderParam)){
$order = json_decode($orderParam, true);
}
$data = $this->repository->paginate(
"c",
$searchText,
$columns,
$joins,
$filter,
$order,
$limit,
$offset,
$filterDelete
);
foreach ($data["rows"] as $key => $item) {
$item = (object)$item;
$item->title = StringUtil::fromUnicode($item->title);
$data["rows"][$key] = $item;
}
return $this->eadResponse($data);
}
/**
* @Route(
* path = "/index/{id}",
* methods = {"GET"},
* requirements = { "id" = "\d+" }
* )
*/
public function getCourseIndex(Request $request) {
$courseId = $request->get('id');
$course = $this->repository->findOneBy([
"id" => $courseId,
"deleted" => CourseEnum::ITEM_NO_DELETED
]);
if(!$course){
return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
}
$isInTeam = $this->em->getRepository(CourseTeam::class)->userExistInCourseTeam(
$course,
$this->user
);
$enrollmentRepository = $this->em->getRepository(Enrollment::class);
$enrollment = $enrollmentRepository->findOneBy([
"user" => $this->user->getId(),
"course" => (int)$request->get('id'),
"deleted" => EnrollmentEnum::ITEM_NO_DELETED,
], [ "id" => "DESC" ]);
$permission = $this->userPermissionUtil->getPermission("course", "see");
if(!$enrollment){
if($course->getFree() == CourseEnum::NO){
if($this->userPermissionUtil->isLow($permission)){
return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
}
if(!$isInTeam && $this->userPermissionUtil->isMiddle($permission)){
return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
}
}
$enrollmentService = $this->generalService->getService('EnrollmentService');
$info = $enrollmentService->enrollUser($this->user, $course);
if(!$info->errors){
$enrollment = $info->enrollment;
}else{
return $this->eadResponse($info->errors, ErrorEnum::FIELD_EMPTY);
}
}
if($this->userPermissionUtil->isLow($permission) && !$isInTeam){
if(!$enrollment){
return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
}
if($course->getStatus() == CourseEnum::DRAFT){
return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
}
}
if(!$enrollment){
return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
}
$courseIndex = $enrollmentRepository->getCourseIndexByEnrollment($enrollment, true);
$clientImage = $this->fileService->getFilePathComplete(
$this->configuration->get('logo'),
CourseEnum::PATH_OTHERS,
true,
true,
'logo-lesson'
);
$clientLessonImage = $this->fileService->getFilePathComplete(
$this->configuration->get('logo_lesson'),
CourseEnum::PATH_OTHERS,
true,
true,
'logo-lesson'
);
$productOfferRepository = $this->em->getRepository(ProductOffer::class);
$productOffersCertificate = $productOfferRepository->getProductOffersByCourse(
$course,
ProductEnum::CERTIFICATE
);
foreach ($productOffersCertificate as $key => $productOffer) {
$productOffersCertificate[$key] = $productOffer->toReturnClean();
$productOffersCertificate[$key]->type = ProductEnum::CERTIFICATE;
}
$productOffersPeriodSupport = $productOfferRepository->getProductOffersByCourse(
$course,
ProductEnum::PERIOD_SUPORT
);
foreach ($productOffersPeriodSupport as $key => $productOffer) {
$productOffersPeriodSupport[$key] = $productOffer->toReturnClean();
$productOffersPeriodSupport[$key]->type = ProductEnum::PERIOD_SUPORT;
}
$productOffersPeriod = $productOfferRepository->getProductOffersByCourse(
$course,
ProductEnum::PERIOD
);
foreach ($productOffersPeriod as $key => $productOffer) {
$productOffersPeriod[$key] = $productOffer->toReturnClean();
$productOffersPeriod[$key]->type = ProductEnum::PERIOD;
}
$productOffersSupport = $productOfferRepository->getProductOffersByCourse(
$course,
ProductEnum::SUPPORT
);
foreach ($productOffersSupport as $key => $productOffer) {
$productOffersSupport[$key] = $productOffer->toReturnClean();
$productOffersSupport[$key]->type = ProductEnum::SUPPORT;
}
$user = $enrollment->getUser();
$drmFontColor = $this->configuration->get("drm_font_color_video");
if(empty($drmFontColor)){
$drmFontColor = $this->configuration->get("primary_color_video");
}
if(empty($drmFontColor)){
$drmFontColor = "#08EC6C";
}
$drmFontSize = $this->configuration->get("drm_font_size_video");
if(empty($drmFontSize)){
$drmFontSize = 12;
}
$drmVideo = CourseEnum::NO;
$drmShowIdVideo = CourseEnum::NO;
$drmShowIpVideo = CourseEnum::NO;
$drmShowDocumentVideo = CourseEnum::NO;
if($this->configuration->checkModuleIsAbleOnPlan('lessonControlFunction')){
$drmVideo = $this->configuration->get("drm_video");
$drmShowIdVideo = $this->configuration->get("drm_show_user_id_video");
$drmShowIpVideo = $this->configuration->get("drm_show_user_ip_video");
$drmShowDocumentVideo = $this->configuration->get(
"drm_show_user_document_video"
);
}
$data = [
"productOffersCertificate" => $productOffersCertificate,
"productOffersPeriod" => array_merge(
$productOffersPeriodSupport,
$productOffersPeriod
),
"productOffersSupport" => array_merge(
$productOffersPeriodSupport,
$productOffersSupport
),
"canAccessAdm" => $this->userPermissionUtil->canAccessAdm(),
"courseIndex" => $courseIndex,
"clientImage" => $clientImage,
"clientLessonImage" => $clientLessonImage,
"clientBrand" => $this->client->getBrand(),
"drmAllowCopyPdf" => $this->configuration->get("drm_allow_copy_pdf"),
"drmAllowPrintPdf" => $this->configuration->get("drm_allow_print_pdf"),
"drmAllowDownloadPdf" => $this->configuration->get("drm_allow_download_pdf"),
"drmFontColor" => $drmFontColor,
"drmFontSize" => $drmFontSize,
"drmVideo" => $drmVideo,
"drmShowIdVideo" => $drmShowIdVideo,
"drmShowIpVideo" => $drmShowIpVideo,
"drmShowDocumentVideo" => $drmShowDocumentVideo,
"date" => date('Y-m-d H:i:s'),
"user" => (object)[
"id" => $user->getId(),
"ip" => $request->getClientIp(),
"name" => $user->getName(),
"document" => $user->getDocument(),
"username" => $user->getUsername(),
"photo" => $user->getPhoto(true),
"permissionName" => (
$user->getUserProfile() ?
$user->getUserProfile()->getName()
: null
),
],
];
return $this->eadResponse($data);
}
/**
* @Route(
* path = "/progress/{id}",
* methods = {"GET"},
* requirements = { "id" = "\d+" }
* )
*/
public function getCourseProgress(Request $request) {
$courseId = $request->get('id');
$course = $this->repository->findOneBy([
"id" => $courseId,
"deleted" => CourseEnum::ITEM_NO_DELETED
]);
if(!$course){
return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
}
$isInTeam = $this->em->getRepository(CourseTeam::class)->userExistInCourseTeam(
$course,
$this->user
);
$enrollmentRepository = $this->em->getRepository(Enrollment::class);
$enrollment = $enrollmentRepository->findOneBy([
"user" => $this->user->getId(),
"course" => (int)$request->get('id'),
"deleted" => EnrollmentEnum::ITEM_NO_DELETED,
]);
$permission = $this->userPermissionUtil->getPermission("course", "see");
if(!$enrollment){
if($course->getFree() == CourseEnum::NO){
if($this->userPermissionUtil->isLow($permission)){
return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
}
if(!$isInTeam && $this->userPermissionUtil->isMiddle($permission)){
return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
}
}
$enrollmentService = $this->generalService->getService('EnrollmentService');
$info = $enrollmentService->enrollUser($this->user, $course);
if(!$info->errors){
$enrollment = $info->enrollment;
}
}
if($this->userPermissionUtil->isLow($permission) && !$isInTeam){
if($course->getStatus() == CourseEnum::DRAFT){
return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
}
}
$certificate = $enrollmentRepository->checkAndIssueCertificate($enrollment);
$courseHasCertificate = ($course->getCertificate() == CourseEnum::YES);
$certificateSale = false;
$linkPdf = null;
$linkBuy = null;
if($courseHasCertificate){
if(!$certificate && $enrollment->getCertificate() == EnrollmentEnum::NO){
$productOfferRepository = $this->em->getRepository(ProductOffer::class);
$certificateOffer = $productOfferRepository->getProductOfferCertificateByCourse(
$course
);
if($certificateOffer){
$certificateSale = true;
$linkBuy = $this->generalService->generateUrl("cartAdd", [
"poID" => $certificateOffer->getId(),
"courseId" => $course->getId(),
]);
}
}
}
if($certificate){
$linkPdf = $this->generalService->generateUrl("viewCertificate", [
"code" => $certificate->getCode(),
"date" => $certificate->getDateIssue('Y-m-d'),
]);
}
return $this->eadResponse([
"progress" => $enrollment->getProgress(),
"courseHasCertificate" => $courseHasCertificate,
"certificateIssue" => ($certificate ? true : false),
"certificateLink" => $linkPdf,
"certificateSale" => $certificateSale,
"certificateLinkBuy" => $linkBuy,
]);
}
/**
* @Route(
* path = "/content/{id}",
* methods = {"GET"},
* requirements = { "id" = "\d+" }
* )
*/
public function getCourseContent(Request $request) {
$courseId = $request->get('id');
$course = $this->repository->findOneBy([
"id" => $courseId,
"deleted" => CourseEnum::ITEM_NO_DELETED
]);
if (!$course) {
return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
}
$isInTeam = $this->em->getRepository(CourseTeam::class)->userExistInCourseTeam(
$course,
$this->user
);
$permission = $this->userPermissionUtil->getPermission("course", "see");
if($this->userPermissionUtil->isLow($permission) && !$isInTeam){
return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
}
$data = $this->repository->getCourseContent($course);
return $this->eadResponse($data);
}
/**
* @Route(
* path = "/check/user/{id}",
* methods = {"GET"},
* requirements = { "id" = "\d+" }
* )
*/
public function checkIsInCourseTeam(Request $request){
$courseId = $request->get('id');
$course = $this->repository->findOneBy([
"id" => $courseId
]);
if (!$course) {
return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
}
$isInTeam = $this->em->getRepository(CourseTeam::class)->userExistInCourseTeam(
$course,
$this->user
);
return $this->eadResponse([ "is" => ( $isInTeam ? 1 : 0 ) ]);
}
/**
* @Route(
* path = "/detail/{id}",
* methods = {"GET"},
* requirements = { "id" = "\d+" }
* )
*/
public function getCourse(Request $request) {
$permission = $this->userPermissionUtil->getPermission("course", "see");
if($this->userPermissionUtil->isLow($permission)){
return $this->eadResponse(null, ErrorEnum::PERMISSION);
}
$courseId = $request->get('id');
$course = $this->repository->findOneBy([
"id" => $courseId,
"deleted" => CourseEnum::ITEM_NO_DELETED
]);
if (!$course) {
return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
}
$courseTeamRepository = $this->em->getRepository(CourseTeam::class);
$isInTeam = $courseTeamRepository->userExistInCourseTeam(
$course,
$this->user
);
if(!$isInTeam && $this->userPermissionUtil->isMiddle($permission)){
return $this->eadResponse(null, ErrorEnum::PERMISSION);
}
$courseTeam = $courseTeamRepository->findOneBy([
"course" => $course->getId(),
"user" => $course->getUser()->getId(),
"deleted" => CourseTeamEnum::ITEM_NO_DELETED
]);
$data = $course->toReturn();
$numberOfPublishCourses = $this->repository->count([
"deleted" => CourseEnum::ITEM_NO_DELETED,
"status" => CourseEnum::PUBLISHED
]);
$data['numberOfPublishCourses'] = $numberOfPublishCourses;
$data['courseTeam'] = ($courseTeam ? $courseTeam->getId() : null);
$data['isInTeam'] = $isInTeam;
$data['urlCourseIndex'] = $this->generalService->generateUrl('courseIndex', [
'id' => $courseId
]);
return $this->eadResponse($data);
}
/**
* @Route(
* path = "/register",
* methods = {"POST"},
* )
*/
public function registerCourse(Request $request) {
$permission = $this->userPermissionUtil->getPermission("course", "create");
if($this->userPermissionUtil->isLow($permission)){
return $this->eadResponse(null, ErrorEnum::PERMISSION);
}
$this->requestUtil->setRequest($request)->setData();
$filePhoto = $this->requestUtil->getFile('photo');
$fileCover = $this->requestUtil->getFile('cover');
$course = new Course();
if($this->requestUtil->issetField('order')){
$course->setOrder((int)$this->requestUtil->getField("order"));
}
if($this->requestUtil->issetField('title')){
$course->setTitle($this->requestUtil->getField("title"));
}
if($this->requestUtil->issetField('certificate')){
$course->setCertificate((int)$this->requestUtil->getField("certificate"));
}
if($this->requestUtil->issetField('certificatePeriod')){
$course->setCertificatePeriod(
(int)$this->requestUtil->getField("certificatePeriod")
);
}
if($this->requestUtil->issetField('configPeriodMinConclusion')){
$course->setConfigPeriodMinConclusion(
(int)$this->requestUtil->getField("configPeriodMinConclusion")
);
}
if($this->requestUtil->issetField('certificateAverage')){
$course->setCertificateAverage(
(float)$this->requestUtil->getField("certificateAverage")
);
}
if($this->requestUtil->issetField('dateRelease')){
$course->setDateRelease($this->requestUtil->getField("dateRelease"));
}
if($this->requestUtil->issetField('support')){
$course->setSupport((int)$this->requestUtil->getField("support"));
}
if($this->requestUtil->issetField('supportPeriod')){
$course->setSupportPeriod($this->requestUtil->getField("supportPeriod"));
}
if($this->requestUtil->issetField('lifetimeSupport')){
$course->setLifetimeSupport((int)$this->requestUtil->getField("lifetimeSupport"));
}
if($this->requestUtil->issetField('workload')){
$course->setWorkload($this->requestUtil->getField("workload"));
}
$course->setStatus(CourseEnum::DRAFT);
if($this->requestUtil->issetField('free')){
$course->setFree((int)$this->requestUtil->getField("free"));
}
if($this->requestUtil->issetField('accessPeriod')){
$course->setAccessPeriod($this->requestUtil->getField("accessPeriod"));
}
if($this->requestUtil->issetField('lifetimePeriod')){
$course->setLifetimePeriod((int)$this->requestUtil->getField("lifetimePeriod"));
}
if($this->requestUtil->issetField('courseCertificateTemplate')){
$courseCertificateTemplateId = (int)$this->requestUtil->getField(
'courseCertificateTemplate'
);
$templateRepository = $this->em->getRepository(CourseCertificateTemplate::class);
$certificateTemplate = $templateRepository->findOneBy([
"id" => $courseCertificateTemplateId,
"deleted" => CourseEnum::ITEM_NO_DELETED
]);
if($certificateTemplate){
$course->setCourseCertificateTemplate($certificateTemplate);
}
}
if($this->requestUtil->issetField('courseCategory')){
$categoryId = (int)$this->requestUtil->getField('courseCategory');
if($categoryId > 0){
$category = $this->em->getRepository(Category::class)->findOneBy([
"id" => $categoryId,
"deleted" => CourseEnum::ITEM_NO_DELETED
]);
if($category){
$course->setCategory($category);
}
}
}
if($this->requestUtil->issetField('user')){ //set User in Course
$userId = $this->requestUtil->getField('user');
if($userId > 0 && $this->userPermissionUtil->isHigh($permission)){
$user = $this->em->getRepository(User::class)->findOneBy([
"id" => $userId,
"deleted" => CourseEnum::ITEM_NO_DELETED
]);
if($user){
$course->setUser($user);
}
}else if($userId == $this->user->getId()){
$course->setUser($this->user);
}
}else{
$course->setUser($this->user);
}
//Define Course order
$order = $course->getOrder();
$lastOrder = $this->repository->count([
"deleted" => CourseEnum::ITEM_NO_DELETED
]) + 1;
if(empty($order) || ($order > $lastOrder)){
$course->setOrder($lastOrder);
$order = $lastOrder;
}
if($course->getStatus() == CourseEnum::DRAFT){
$course->setOrder($lastOrder);
$order = $lastOrder;
}
$errors = $this->validateEntity($course);
if($errors){
return $this->eadResponse($errors, ErrorEnum::FIELD_EMPTY);
}
if($filePhoto){
$filePhoto = $this->fileService->setFile($filePhoto);
if($filePhoto){
$this->fileService->moveFile(CourseEnum::PATH_STORE);
$course->setPhoto($this->fileService->getFileName());
}
}
if($fileCover){
$fileCover = $this->fileService->setFile($fileCover);
if($fileCover){
$this->fileService->moveFile(CourseEnum::PATH_COVERS);
$course->setCover($this->fileService->getFileName());
}
}
//Update all register to understand the new order
$this->repository->refreshOrder(null, $order);
$courseTeam = new CourseTeam();
$courseTeam->setCourse($course);
$courseTeam->setUser($course->getUser());
$this->em->persist($course);
$this->em->persist($courseTeam);
$this->em->flush();
$data = $course->toReturn();
$this->userLogService->logInsert("course", $course->getId(), $data);
return $this->eadResponse($data);
}
/**
* @Route(
* path = "/edit/{id}",
* methods = {"POST"},
* requirements = { "id" = "\d+" }
* )
*/
public function editCourse(Request $request) {
$permission = $this->userPermissionUtil->getPermission("course", "edit");
if($this->userPermissionUtil->isLow($permission)){
return $this->eadResponse(null, ErrorEnum::PERMISSION);
}
$this->requestUtil->setRequest($request)->setData();
$courseId = $request->get('id');
$course = $this->repository->findOneBy([
"id" => $courseId,
"deleted" => CourseEnum::ITEM_NO_DELETED
]);
if (!$course) {
return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
}
$isInTeam = $this->em->getRepository(CourseTeam::class)->userExistInCourseTeam(
$course,
$this->user
);
if(!$isInTeam && $this->userPermissionUtil->isMiddle($permission)){
return $this->eadResponse(null, ErrorEnum::PERMISSION);
}
$filePhoto = $this->requestUtil->getFile('photo');
$fileCover = $this->requestUtil->getFile('cover');
$oldOrder = $course->getOrder();
if($this->requestUtil->issetField('order')){
$course->setOrder((int)$this->requestUtil->getField("order"));
}
if($this->requestUtil->issetField('title')){
$course->setTitle($this->requestUtil->getField("title"));
}
if($this->requestUtil->issetField('certificatePeriod')){
$course->setCertificatePeriod((int)$this->requestUtil->getField("certificatePeriod"));
}
if($this->requestUtil->issetField('configPeriodMinConclusion')){
$course->setConfigPeriodMinConclusion(
(int)$this->requestUtil->getField("configPeriodMinConclusion")
);
}
if($this->requestUtil->issetField('certificate')){
$course->setCertificate((int)$this->requestUtil->getField("certificate"));
}
if($this->requestUtil->issetField('certificateAverage')){
$course->setCertificateAverage(
(float)$this->requestUtil->getField("certificateAverage")
);
}
if($this->requestUtil->issetField('dateRelease')){
$course->setDateRelease($this->requestUtil->getField("dateRelease"));
}
if($this->requestUtil->issetField('support')){
$course->setSupport((int)$this->requestUtil->getField("support"));
}
if($this->requestUtil->issetField('supportPeriod')){
$course->setSupportPeriod($this->requestUtil->getField("supportPeriod"));
}
if($this->requestUtil->issetField('lifetimeSupport')){
$course->setLifetimeSupport((int)$this->requestUtil->getField("lifetimeSupport"));
}
if($this->requestUtil->issetField('workload')){
$course->setWorkload($this->requestUtil->getField("workload"));
}
$oldStatus = $course->getStatus();
if($this->requestUtil->issetField('status')){
$course->setStatus((int)$this->requestUtil->getField("status"));
}
if($this->requestUtil->issetField('free')){
$course->setFree((int)$this->requestUtil->getField("free"));
}
if($this->requestUtil->issetField('accessPeriod')){
$course->setAccessPeriod($this->requestUtil->getField("accessPeriod"));
}
if($this->requestUtil->issetField('lifetimePeriod')){
$course->setLifetimePeriod((int)$this->requestUtil->getField("lifetimePeriod"));
}
if($this->requestUtil->issetField('courseCertificateTemplate')){
$courseCertificateTemplateId = (int)$this->requestUtil->getField(
'courseCertificateTemplate'
);
$templateRepository = $this->em->getRepository(CourseCertificateTemplate::class);
$certificateTemplate = $templateRepository->findOneBy([
"id" => $courseCertificateTemplateId,
"deleted" => CourseEnum::ITEM_NO_DELETED
]);
if($certificateTemplate){
$course->setCourseCertificateTemplate($certificateTemplate);
}
}
if($this->requestUtil->issetField('courseCategory')){
$categoryId = (int)$this->requestUtil->getField('courseCategory');
$category = $this->em->getRepository(Category::class)->findOneBy([
"id" => $categoryId,
"deleted" => CourseEnum::ITEM_NO_DELETED
]);
if($category){
$course->setCategory($category);
}
}
if($this->requestUtil->issetField('courseTeam')){
$courseTeamId = $this->requestUtil->getField('courseTeam');
if($courseTeamId > 0 && $this->userPermissionUtil->isHigh($permission)){
$courseTeam = $this->em->getRepository(CourseTeam::class)->findOneBy([
"id" => $courseTeamId,
"course" => $course->getId(),
"deleted" => CourseTeamEnum::ITEM_NO_DELETED
]);
if($courseTeam){
$course->setUser($courseTeam->getUser());
}
}
}
$lastOrder = $this->repository->count([ "deleted" => CourseEnum::ITEM_NO_DELETED ]);
$newOrder = $course->getOrder();
if(empty($newOrder) || $newOrder > $lastOrder){
$course->setOrder($lastOrder);
$newOrder = $lastOrder;
}
if($course->getStatus() == CourseEnum::DRAFT){
$course->setOrder($lastOrder);
$newOrder = $lastOrder;
}
if($filePhoto){
$filePhoto = $this->fileService->setFile($filePhoto);
if($filePhoto){
$this->fileService->moveFile(CourseEnum::PATH_STORE);
$course->setPhoto($this->fileService->getFileName());
}
}
if($fileCover){
$fileCover = $this->fileService->setFile($fileCover);
if($fileCover){
$this->fileService->moveFile(CourseEnum::PATH_COVERS);
$course->setCover($this->fileService->getFileName());
}
}
$errors = $this->validateEntity($course);
if($errors){
return $this->eadResponse($errors, ErrorEnum::FIELD_EMPTY);
}
if(!$this->configuration->checkModuleIsAbleOnPlan('unlimitedCourseFunction')){
$publishCourses = $this->repository->count([
"deleted" => CourseEnum::ITEM_NO_DELETED,
"status" => CourseEnum::PUBLISHED
]);
if(
!empty($publishCourses) &&
$course->getStatus() == CourseEnum::PUBLISHED &&
$oldStatus != $course->getStatus()
){
return $this->eadResponse([ "status" ], ErrorEnum::FIELD_EMPTY);
}
}
$course->setDateUpdate(date('Y-m-d H:i:s'));
if($oldOrder != $newOrder){
$this->repository->refreshOrder($oldOrder, $newOrder);
}
$this->em->flush();
$products = $course->getProduct();
foreach ($products as $key => $product) {
$this->repository->getAllCourseTimeByProduct($product, true);
}
$data = $course->toReturn();
$this->userLogService->logUpdate("course", $course->getId(), $data);
return $this->eadResponse($data);
}
/**
* @Route(
* path = "/edit/lesson/control/{id}",
* methods = {"PUT"},
* requirements = { "id" = "\d+" }
* )
*/
public function editCourseLessonControl(Request $request) {
$permission = $this->userPermissionUtil->getPermission(
"course",
"lesson",
"access_control"
);
if($this->userPermissionUtil->isLow($permission)){
return $this->eadResponse(null, ErrorEnum::PERMISSION);
}
if(!$this->configuration->checkModuleIsAbleOnPlan('lessonControlFunction')){
return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
}
$this->requestUtil->setRequest($request)->setData();
$courseId = $request->get('id');
$course = $this->repository->findOneBy([
"id" => $courseId,
"deleted" => CourseEnum::ITEM_NO_DELETED
]);
if (!$course) {
return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
}
$isInTeam = $this->em->getRepository(CourseTeam::class)->userExistInCourseTeam(
$course,
$this->user
);
if(!$isInTeam && $this->userPermissionUtil->isMiddle($permission)){
return $this->eadResponse(null, ErrorEnum::PERMISSION);
}
if($this->requestUtil->issetField('controlLessonRequirement')){
$course->setControlLessonRequirement(
(int)$this->requestUtil->getField("controlLessonRequirement")
);
}
if($this->requestUtil->issetField('controlLessonReleaseType')){
$course->setControlLessonReleaseType(
(int)$this->requestUtil->getField("controlLessonReleaseType")
);
}
if($this->requestUtil->issetField('controlLessonAfterType')){
$course->setControlLessonAfterType(
(int)$this->requestUtil->getField("controlLessonAfterType")
);
}
if($this->requestUtil->issetField('controlLessonDateRelease')){
$course->setControlLessonDateRelease(
$this->requestUtil->getField("controlLessonDateRelease")
);
}
if($this->requestUtil->issetField('controlLessonReleasePeriod')){
$course->setControlLessonReleasePeriod(
(int)$this->requestUtil->getField("controlLessonReleasePeriod")
);
}
if($this->requestUtil->issetField('controlLessonClosePeriod')){
$course->setControlLessonClosePeriod(
(int)$this->requestUtil->getField("controlLessonClosePeriod")
);
}
if($this->requestUtil->issetField('controlLessonTime')){
$course->setControlLessonTime(
(int)$this->requestUtil->getField("controlLessonTime")
);
}
if($this->requestUtil->issetField('controlLessonTimeStay')){
$course->setControlLessonTimeStay(
$this->requestUtil->getField("controlLessonTimeStay")
);
}
if($this->requestUtil->issetField('controlLessonViewLimit')){
$course->setControlLessonViewLimit(
(int)$this->requestUtil->getField("controlLessonViewLimit")
);
}
if($this->requestUtil->issetField('controlLessonViewNumber')){
$course->setControlLessonViewNumber(
(int)$this->requestUtil->getField("controlLessonViewNumber")
);
}
if($this->requestUtil->issetField('controlLessonShowDocument')){
$course->setControlLessonShowDocument(
(int)$this->requestUtil->getField("controlLessonShowDocument")
);
}
if($this->requestUtil->issetField('controlLessonApply')){
$course->setControlLessonApply(
(int)$this->requestUtil->getField("controlLessonApply")
);
}
if($course->getControlLessonTimeStay() == "00:00:00"){
$course->setControlLessonTimeStay(null);
}
$groupsValidation = [];
if($course->getControlLessonReleaseType() == CourseEnum::LESSON_FIXED_DATE){
$groupsValidation[] = "controlReleaseTypeFixed";
}else if($course->getControlLessonReleaseType() == CourseEnum::LESSON_FLEXIBLE_DATE){
$groupsValidation[] = "controlReleaseTypeFlex";
}
if($course->getControlLessonViewLimit() == CourseEnum::YES){
$groupsValidation[] = "limitedView";
}
$errors = $this->validateEntity($course, $groupsValidation);
if($errors){
return $this->eadResponse($errors, ErrorEnum::FIELD_EMPTY);
}
$course->setDateUpdate(date('Y-m-d H:i:s'));
$this->em->flush();
if($course->getControlLessonApply() != CourseEnum::ONLY_NEW_LESSONS){
$this->repository->applyCourseLessonConfigAll($course);
}
$data = $course->toReturn();
$this->userLogService->logUpdate("course", $course->getId(), $data);
return $this->eadResponse($data);
}
/**
* @Route(
* path = "/edit/many/status",
* methods = {"PUT"}
* )
*/
public function editManyStatusCourse(Request $request) {
$permission = $this->userPermissionUtil->getPermission("course", "edit");
if($this->userPermissionUtil->isLow($permission)){
return $this->eadResponse(null, ErrorEnum::PERMISSION);
}
if(!$this->configuration->checkModuleIsAbleOnPlan('unlimitedCourseFunction')){
return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
}
$this->requestUtil->setRequest($request)->setData();
$courseId = $this->requestUtil->getField('courses');
if(empty($courseId)){
return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
};
$courseId = json_decode($courseId);
foreach ($courseId as $key => $id) {
$course = $this->repository->findOneBy([
"id" => $id,
"deleted" => CourseEnum::ITEM_NO_DELETED
]);
if($course) {
if($this->requestUtil->issetField('status')){
$course->setStatus((int)$this->requestUtil->getField('status'));
}
$errors = $this->validateEntity($course);
if(!$errors){
$this->em->flush();
$products = $course->getProduct();
foreach ($products as $key => $product) {
$this->repository->getAllCourseTimeByProduct($product, true);
}
$data = $course->toReturn();
$this->userLogService->logUpdate(
"course",
$course->getId(),
$data
);
}
}
}
return $this->eadResponse([ "message" => "Success" ]);
}
/**
* @Route(
* path = "/add/product/{id}",
* methods = {"POST"},
* requirements = { "id" = "\d+" }
* )
*/
public function addProduct(Request $request) {
$permission = $this->userPermissionUtil->getPermission(
"product",
"product_course",
"add"
);
if($this->userPermissionUtil->isLow($permission)){
return $this->eadResponse(null, ErrorEnum::PERMISSION);
}
$this->requestUtil->setRequest($request)->setData();
$courseId = $request->get('id');
$course = $this->repository->findOneBy([
"id" => $courseId,
"deleted" => CourseEnum::ITEM_NO_DELETED
]);
if (!$course){
return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
}
$products = $this->requestUtil->getField('products');
if(empty($products)){
return $this->eadResponse([ "products" ], ErrorEnum::FIELD_EMPTY);
}
$products = json_decode($products);
if(!is_array($products)){
return $this->eadResponse([ "products" ], ErrorEnum::FIELD_EMPTY);
}
if(is_array($products)){
$productRepository = $this->em->getRepository(Product::class);
foreach ($products as $key => $productId) {
$product = $productRepository->findOneBy([
"id" => $productId,
"deleted" => ProductEnum::ITEM_NO_DELETED
]);
if($product){
$isInTeam = $this->em->getRepository(ProductTeam::class)->userExistInProductTeam(
$product, $this->user
);
if(!$isInTeam && $this->userPermissionUtil->isMiddle($permission)){
continue;
}
if($product->getType() == ProductEnum::COURSE){
if(count($product->getCourse()) > 0){
continue;
}
}
$product->addCourse($course);
if($product->getType() == ProductEnum::SUBSCRIPTION){
$this->em->getRepository(UserSubscription::class)->enrollUsers(
$product,
[ $course ]
);
}
$data = [
'courses' => [ $course->getId() ],
];
$this->userLogService->logInsert(
"product_x_course",
$product->getId(),
$data
);
}
}
$this->em->flush();
}
$products = $course->getProduct();
foreach ($products as $key => $product) {
$this->repository->getAllCourseTimeByProduct($product, true);
}
return $this->eadResponse([ "message" => "Success" ]);
}
/**
* @Route(
* path = "/remove/product/many/{courseId}",
* methods = {"DELETE"},
* requirements = { "courseId" = "\d+" }
* )
*/
public function removeManyProduct(Request $request) {
$permission = $this->userPermissionUtil->getPermission(
"product",
"product_course",
"remove"
);
if($this->userPermissionUtil->isLow($permission)){
return $this->eadResponse(null, ErrorEnum::PERMISSION);
}
$courseId = $request->get('courseId');
$course = $this->repository->findOneBy([
"id" => $courseId,
"deleted" => CourseEnum::ITEM_NO_DELETED
]);
if (!$course) {
return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
}
$isInTeam = $this->em->getRepository(CourseTeam::class)->userExistInCourseTeam(
$course,
$this->user
);
if(!$isInTeam && $this->userPermissionUtil->isMiddle($permission)){
return $this->eadResponse(null, ErrorEnum::PERMISSION);
}
$this->requestUtil->setRequest($request)->setData();
$all = (int)$this->requestUtil->getField('all');
$products = json_decode($this->requestUtil->getField('products'));
if(empty($all)){
if(empty($products) || !is_array($products)){
return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
}
}
$productRepository = $this->em->getRepository(Product::class);
if($all == CourseEnum::YES){
$course->removeAllProduct();
}else{
foreach ($products as $key => $productId) {
$product = $productRepository->findOneBy([
"id" => $productId,
"deleted" => ProductEnum::ITEM_NO_DELETED
]);
if ($product) {
$course->removeProduct($product);
}
}
}
$this->em->flush();
$products = $course->getProduct();
foreach ($products as $key => $product) {
$this->repository->getAllCourseTimeByProduct($product, true);
}
$this->userLogService->logDeleteMany(
"course_x_product",
$course->getId(),
[
"all" => $all,
"products" => $products
]
);
return $this->eadResponse([ "message" => "Success" ]);
}
/**
* @Route(
* path = "/copy/{id}",
* methods = {"COPY"},
* requirements = { "id" = "\d+"}
* )
*/
public function copyCourse(Request $request) {
if(!$this->configuration->checkModuleIsAbleOnPlan('copyFunction')){
return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
}
$permission = $this->userPermissionUtil->getPermission("course", "copy");
if($this->userPermissionUtil->isLow($permission)){
return $this->eadResponse(null, ErrorEnum::PERMISSION);
}
$courseId = $request->get('id');
$course = $this->repository->findOneBy([
"id" => $courseId,
"deleted" => CourseEnum::ITEM_NO_DELETED
]);
if(!$course){
return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
}
$isInTeam = $this->em->getRepository(CourseTeam::class)->userExistInCourseTeam(
$course,
$this->user
);
if(!$isInTeam && $this->userPermissionUtil->isMiddle($permission)){
return $this->eadResponse(null, ErrorEnum::PERMISSION);
}
$newCourse = $this->repository->copyCourse($course);
$data = $newCourse->toReturn();
$this->userLogService->logInsert("course", $newCourse->getId(), $data);
return $this->eadResponse($data);
}
/**
* @Route(
* path = "/delete/cover/{id}",
* methods = {"DELETE"},
* requirements = { "id" = "\d+" }
* )
*/
public function deleteCourseCover(Request $request) {
$permission = $this->userPermissionUtil->getPermission("course", "edit");
if($this->userPermissionUtil->isLow($permission)){
return $this->eadResponse(null, ErrorEnum::PERMISSION);
}
$courseId = $request->get('id');
$course = $this->repository->findOneBy([
"id" => $courseId,
"deleted" => CourseEnum::ITEM_NO_DELETED
]);
if (!$course) {
return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
}
$isInTeam = $this->em->getRepository(CourseTeam::class)->userExistInCourseTeam(
$course,
$this->user
);
if(!$isInTeam && $this->userPermissionUtil->isMiddle($permission)){
return $this->eadResponse(null, ErrorEnum::PERMISSION);
}
if($course->getCover()){
$pathComplete = $this->fileService->getFilePathComplete(
$course->getCover(),
CourseEnum::PATH_COVERS
);
$this->fileService->setFile($pathComplete);
$this->fileService->deleteFile();
$course->setCover(null);
}
$this->em->flush();
$data = $course->toReturn();
$this->userLogService->logUpdate("course", $course->getId(), $data);
return $this->eadResponse($data);
}
/**
* @Route(
* path = "/delete/photo/{id}",
* methods = {"DELETE"},
* requirements = { "id" = "\d+" }
* )
*/
public function deleteCoursePhoto(Request $request) {
$permission = $this->userPermissionUtil->getPermission("course", "edit");
if($this->userPermissionUtil->isLow($permission)){
return $this->eadResponse(null, ErrorEnum::PERMISSION);
}
$courseId = $request->get('id');
$course = $this->repository->findOneBy([
"id" => $courseId,
"deleted" => CourseEnum::ITEM_NO_DELETED
]);
if (!$course) {
return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
}
$isInTeam = $this->em->getRepository(CourseTeam::class)->userExistInCourseTeam(
$course,
$this->user
);
if(!$isInTeam && $this->userPermissionUtil->isMiddle($permission)){
return $this->eadResponse(null, ErrorEnum::PERMISSION);
}
if($course->getPhoto()){
$pathComplete = $this->fileService->getFilePathComplete(
$course->getPhoto(),
CourseEnum::PATH_STORE
);
$this->fileService->setFile($pathComplete);
$this->fileService->deleteFile();
$course->setPhoto(null);
}
$this->em->flush();
$data = $course->toReturn();
$this->userLogService->logUpdate("course", $course->getId(), $data);
return $this->eadResponse($data);
}
}

src/Controller/Admin/CourseController.php line 988