Symfony Profiler

<?php
namespace App\Controller;
use App\Event\HolidayEvent;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\Security\Core\Exception\AccessDeniedException;
use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;
use Symfony\Component\Security\Core\User\UserInterface;
use Pimcore\Model\Asset;
use Pimcore\Model\DataObject;
use Pimcore\Model\Document;
use Pimcore\Model\Element\Tag;
use Pimcore\Model\DataObject\Data\BlockElement;
use Symfony\Component\Stopwatch\Stopwatch;
use App\Form\ManageUserCreateType;
use App\Form\ManageUserUpdateType;
use App\Form\PasswordFormType;
use App\Form\RegistrationFormHandler;
use App\Model\Customer;
use App\Model\TrycareMembership;
use App\Services\CreateSubuserService;
use App\Services\GeneralService;
use App\Services\HeadOfficeService;
use App\Services\PermissionService;
use App\Services\ToolsService;
use App\Services\NotificationService;
use App\Services\EmployeeContractService;
use App\Services\FreeTrialService;
use App\Services\TrycareService;
use App\Stripe\UserHandler;
use Carbon\Carbon;
use CustomerManagementFrameworkBundle\CustomerProvider\CustomerProviderInterface;
use Error;
use Pimcore\DataObject\Consent\Service;
use Psr\Log\LoggerInterface;
use Symfony\Component\HttpClient\Exception\InvalidArgumentException;
use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
use Symfony\Component\HttpKernel\Exception\PreconditionFailedHttpException;
use Symfony\Component\HttpKernel\Exception\UnauthorizedHttpException;
use Symfony\Contracts\EventDispatcher\EventDispatcherInterface;
/**
* @Route("/api", name="api")
*/
class ApiController extends AbstractController
{
/**
* @Route("/template-hub/templates/read", name="template-hub-read")
*/
public function templateHubReadAction(Stopwatch $stopwatch)
{
if (!$this->isGranted('ROLE_USER')) {
throw new UnauthorizedHttpException('Not authorized.');
}
$listPublic = new DataObject\Templates\Listing();
$listPublic->load();
$listPublic = $listPublic->getData();
$listCategories = array_map(function ($template) {
return $template->getCategory();
}, $listPublic);
$listCategories = array_unique($listCategories);
$templatesList = [];
foreach ($listCategories as $category) {
$list = array_filter($listPublic, function ($item) use ($category) {
return $item->getCategory() === $category;
});
$dataContent = [];
foreach ($list as $template) {
/* if ($asset instanceof \Pimcore\Model\Asset\Document) {
try {
if (!$asset->getCustomSetting('document_page_count')) {
$asset->processPageCount();
}
} catch (\Exception $e) {
//do nothing
}
} */
$coverPath = $template->getCover()->getPath();
$coverFilename = $template->getCover()->getFilename();
$dataContent[] = [
'name' => $template->getTitle(),
'id' => $template->getId(),
"preview" => $coverPath . $coverFilename,
"linkDocument" => $template->getDocument()->getFullPath(),
/* "linkPdf" => $template->getPdf()->getFullPath(), */
];
}
$templatesList[] = [
"category" => $category,
"data" => $dataContent
];
}
$response = new Response();
$response->headers->set('Content-Type', 'application/json');
$response->headers->set('Access-Control-Allow-Origin', '*');
$response->setContent(json_encode($templatesList));
return $response;
}
/**
* @Route("/head-office/assets/create", name="template-hub-assets-create", methods={"POST"})
*
* @param Request $request
* @return Response
*/
public function headOfficeAssetCreateAction(Request $request)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$id = $loggedUser->getId();
if ($request->getContent()) {
$data = json_decode($request->getContent(), true);
$fileName = $data['fileKey'];
$title = $data['title'];
$description = $data['description'];
$parentFolder = DataObject::getByPath("/Head Office/Private/" . $id);
if (!$parentFolder) {
$parentFolder = DataObject\Service::createFolderByPath("/Head Office/Private/" . $id);
}
$newObject = new DataObject\HOFile();
$newObject->setKey($fileName);
$newObject->setParent($parentFolder);
$newObject->setTitle($title);
$newObject->setDescription($description);
$newObject->setPublished(true);
$newObject->save();
return new Response($newObject->getId());
}
return new Response(null);
}
/**
* @Route("/head-office/assets/read", name="template-hub-assets-read", methods={"GET"})
*
* @param Request $request
* @return Response
*/
public function headOfficeAssetReadAction(Request $request)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$id = $loggedUser->getId();
$parentFolder = DataObject::getByPath("/Head Office/Private/" . $id);
if ($parentFolder) {
$list = new DataObject\HOFile\Listing();
$list->setCondition("o_parentId = ?", $parentFolder->getId());
$list->load();
$list = $list->getData();
$dataContent = [];
foreach ($list as $file) {
$dataContent[] = [
'title' => $file->getTitle(),
'description' => $file->getDescription(),
'id' => $file->getId(),
'key' => $file->getKey()
];
};
return new Response(json_encode($dataContent));
}
return new Response(null);
}
/**
* @Route("/head-office/assets/delete", name="template-hub-assets-delete", methods={"POST"})
*
* @param Request $request
* @return Response
*/
public function headOfficeAssetDeleteAction(Request $request)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$id = $loggedUser->getId();
if ($request->getContent()) {
$data = json_decode($request->getContent(), true);
$fileId = $data['objectId'];
$object = DataObject::getById($fileId);
$object->delete();
return new Response('File deleted');
}
return new Response(null);
}
/**
* @Route("/head-office/credentials/set-cognito", name="head-office-cognito", methods={"PATCH"})
*
* @param Request $request
* @return Response
*/
public function headOfficeSetVaultAction(Request $request)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$id = $loggedUser->getId();
if ($request->getContent()) {
$data = json_decode($request->getContent(), true);
$cognito = $data['cognitoConfirmed'];
$loggedUser->setCognitoConfirmed($cognito);
$loggedUser->save();
$response = new Response();
return $response->setContent(json_encode(['message' => 'OK']));
}
throw new BadRequestHttpException();
}
/**
* @Route("/head-office/credentials/set", name="head-office-credentials-set", methods={"PUT"}))
*/
public function headOfficeSetCredentialsAction(Request $request, PermissionService $permissionProvider, Service $consentService)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$data = json_decode($request->getContent(), true);
$password = $data['password'];
$cognito = $data['cognito'];
$loggedUser->setPassword($password);
$loggedUser->setCognito($cognito);
$consentService->giveConsent($loggedUser, "termsAndPolicy", "Agreed with website's terms of use and privacy policy.");
try {
$loggedUser->save();
$response = new Response();
return $response->setContent(json_encode(['message' => 'OK']));
} catch (\Exception $e) {
throw new BadRequestHttpException($e);
}
}
/**
* @Route("/head-office/credentials/get", name="head-office-credentials", methods={"GET"}))
*/
public function headOfficeCheckCredentialsAction(PermissionService $permissionProvider)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$id = $loggedUser->getId();
$role = $loggedUser->getTypeOfUser();
$userData = [];
$cpdCycles = [];
foreach ($loggedUser->getCpdCycles() as $cycle) {
$cpdCycles[] = [
'id' => $cycle->getId(),
'startingDate' => $cycle->getStartDate(),
'endDate' => $cycle->getEndDate(),
'createdAt' => $cycle->getCreationDate(),
'requiredHours' => $cycle->getRequiredHours()
];
}
$permissions = $permissionProvider->getPermissions($loggedUser);
$plans = [];
foreach ($loggedUser->getCpdPlans() as $cpdPlan) {
$plans[] = [
'id' => $cpdPlan->getid(),
'createdAt' => $cpdPlan->getCreationDate()
];
}
$clinic = $loggedUser->getClinic();
$clinicBranches = [];
foreach ($clinic->getBranches() as $branch) {
$clinicBranches[] = [
'name' => $branch->getName(),
'isMain' => $branch->getIsMain(),
'id' => $branch->getId(),
'isNew' => $branch->getIsNew()
];
}
$role = $loggedUser->getTypeOfUser();
$subscription = $loggedUser->getSubscription();
$superuser = $clinic->getSuperuser();
$includedSubs = count($superuser->getIncludedSubscriptions());
if ($superuser->getSubscription()->getIsTrycareMembership()) {
$includedSubs = TrycareMembership::getAdditionalSubscriptionsAmount($superuser->getSubscription()->getTrycareMemberId());
}
$userData = [
'id' => $id,
'role' => $loggedUser->getTypeOfUser(),
'cognito' => $loggedUser->getCognito(),
'email' => $loggedUser->getEmail(),
'clinicId' => $clinic->getName(),
'cognitoConfirmed' => $loggedUser->getCognitoConfirmed(),
'firstName' => $loggedUser->getFirstname(),
'lastName' => $loggedUser->getLastname(),
'displayName' => $loggedUser->getDisplayName(),
'profession' => $loggedUser->getProfession(),
'gdcNumber' => $loggedUser->getGdcNumber(),
'cpdCycles' => $cpdCycles,
'newAlert' => $loggedUser->getNewAlert(),
'permissions' => $permissions,
'licence' => [
'endOfCycle' => $subscription->getExpiryDate(),
'cancel' => $subscription->getCancelEndPeriod(),
'cycleType' => $subscription->getBillingCycle(),
'freeTrial' => $subscription->getIsFreeTrial(),
'includedSubs' => $includedSubs
],
'cpdPlans' => $plans,
'clinicBranches' => $clinicBranches,
'newsletter' => $loggedUser->getNewsletterActive(),
'isTrycareMembership' => $subscription->getIsTrycareMembership(),
];
$response = new Response();
$response->headers->set('Content-Type', 'application/json');
$response->headers->set('Access-Control-Allow-Origin', '*');
$response->setContent(json_encode($userData));
return $response;
}
/**
* @Route("/head-office/credentials/update", name="head-office-credentials-update", methods={"PUT"}))
*/
public function headOfficeUpdateUserAction(Request $request, PermissionService $permissionProvider, Service $consentService, UserHandler $userHandler)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$content = json_decode($request->getContent());
$form = $this->createForm(ManageUserUpdateType::class);
$form->submit((array)$content);
if (!$form->isValid()) {
$errors = [];
foreach ($form->getErrors(deep: true, flatten: true) as $error) {
$errors[] = $error->getMessage();
}
throw new BadRequestHttpException(json_encode($errors));
}
$data = json_decode($request->getContent(), true);
if ($loggedUser->getTypeOfUser() === 'subuser' && $data['termsAndPolicy'] != true) {
throw new BadRequestHttpException('You must agree to our terms and policies.');
}
$clinic = $loggedUser->getClinic();
//create main location
if (array_key_exists('firstLineAddress', $data)) {
$branch = $userHandler->createBranch(['name' => $data['firstLineAddress'], 'isMain' => true], $clinic);
$clinic->setBranches([...$clinic->getBranches(), $branch]);
}
$loggedUser->setFirstname($data['firstname']);
$loggedUser->setLastname($data['lastname']);
$loggedUser->setProfession($data['profession']);
$loggedUser->setGdcNumber($data['gdcNumber']);
// $loggedUser->setPhone($data['contact']);
if (array_key_exists('termsAndPolicy', $data)) {
$consentService->giveConsent($loggedUser, "termsAndPolicy", "Agreed with website's terms of use and privacy policy.");
}
if (array_key_exists('dealsAndOffers', $data)) {
$consentMessage = "Consent given for deals and offers";
$consentService->giveConsent($loggedUser, "dealsAndOffers", $consentMessage);
}
if (array_key_exists('cognito', $data)) {
$loggedUser->setCognito($data['cognito']);
}
if (array_key_exists('displayName', $data)) {
$loggedUser->setDisplayName($data['displayName']);
}
if (array_key_exists('password', $data)) {
$loggedUser->setPassword($data['password']);
}
if ($loggedUser->getTypeOfUser() === 'superuser') {
if (array_key_exists('practiceName', $data)) {
$clinic->setDisplayName($data['practiceName']);
}
if (array_key_exists('phone', $data)) {
$clinic->setPhone($data['phone']);
}
$clinic->save();
}
try {
$loggedUser->save();
$response = new Response();
return $response->setContent(json_encode(['message' => 'OK']));
} catch (\Exception $e) {
throw new BadRequestHttpException($e);
}
}
/**
* @Route("/head-office/protocols/get", name="head-office-protocols-get", methods={"GET"}))
*/
public function headOfficeGetProtocolsAction()
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$id = $loggedUser->getId();
$protocols = [
'clinicalPractice',
'riskAssessments',
'decontaminationAndCleaning',
'wasteManagement',
'occupationalHazards',
'miscellaneous'
];
$clinic = $loggedUser->getClinic();
$clinicHealthSafetyProtocols = [];
foreach ($protocols as $protocol) {
$getter = "get" . ucwords($protocol);
$protocolDoc = $clinic->$getter();
if (!empty($protocolDoc)) {
$data = [];
foreach ($protocolDoc as $doc) {
$data[] = [
'title' => $doc->getTitle(),
'date' => $doc->getAddedDate(),
'id' => $doc->getId(),
'key' => $doc->getKey()
];
}
$clinicHealthSafetyProtocols[$protocol] = $data;
} else {
$clinicHealthSafetyProtocols[$protocol] = null;
}
}
$response = new Response();
$response->headers->set('Content-Type', 'application/json');
$response->headers->set('Access-Control-Allow-Origin', '*');
$response->setContent(json_encode($clinicHealthSafetyProtocols));
return $response;
}
/**
* @Route("/head-office/protocols/post", name="head-office-protocols-post", methods={"POST"})
*
* @param Request $request
* @return Response
*/
public function headOfficePostProtocolsAction(Request $request, PermissionService $permissionProvider)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$permissionProvider->checkPermissions('teamHQ', $loggedUser);
if ($request->getContent()) {
$data = json_decode($request->getContent(), true);
$fileName = $data['fileKey'];
$title = $data['title'];
$documentType = $data['documentType'];
$clinic = $loggedUser->getClinic();
$parentFolder = DataObject::getByPath("/Companies/" . $clinic->getName() . "/Protocol Documents");
if (!$parentFolder) {
$parentFolder = DataObject\Service::createFolderByPath("/Companies/" . $clinic->getName() . "/Protocol Documents");
}
$currentDate = date("d/m/Y");
$newObject = new DataObject\ProtocolDocument();
$newObject->setKey($fileName);
$newObject->setParent($parentFolder);
$newObject->setTitle($title);
$newObject->setAddedDate($currentDate);
$newObject->setPublished(true);
$newObject->save();
$getter = "get" . ucwords($documentType);
$setter = "set" . ucwords($documentType);
$currentDocs = $clinic->$getter();
$clinic->$setter(array_merge($currentDocs, [$newObject]));
$clinic->save();
return new Response(json_encode($currentDocs));
}
return new Response(null);
}
/**
* @Route("/head-office/protocols/delete/{id}", name="head-office-protocols-delete", methods={"DELETE"})
*
* @param Request $request
* @return Response
*/
public function headOfficeProtocolsDeleteAction(Request $request, $id, PermissionService $permissionProvider)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$permissionProvider->checkPermissions('teamHQ', $loggedUser);
$object = DataObject::getById($id);
if ($object) {
$object->delete();
return new Response('File deleted');
}
throw new BadRequestHttpException();
}
public function filterForTags($tagIds)
{
$tagIds = is_array($tagIds) ? $tagIds : explode(',', $tagIds);
$listing = new \Pimcore\Model\Asset\Listing();
if ($tagIds) {
$conditionParts = [];
foreach ($tagIds as $tagId) {
$conditionParts[] = "id IN (SELECT cId FROM tags_assignment WHERE ctype = 'asset' AND tagid = " . (int) $tagId . ")";
}
if (count($conditionParts) > 0) {
$condition = implode(" AND ", $conditionParts);
$listing->addConditionParam($condition);
$listing->load();
}
}
return $listing;
}
/**
* @Route("/head-office/locker/", name="head-office-locker-get", methods={"GET"})
*
* @param Request $request
* @return Response
*/
public function headOfficeGetLockerAction()
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('You must be logged in to use this service');
}
$clinic = $loggedUser->getClinic();
$parentFolder = DataObject::getByPath("/Companies/" . $clinic->getName() . "/Locker");
$data = [];
if ($parentFolder) {
$list = new DataObject\LockerDocument\Listing();
$list->setCondition("o_parentId = ?", $parentFolder->getId());
$list->load();
$list = $list->getData();
foreach ($list as $document) {
$data[] = [
'id' => $document->getId(),
'key' => $document->getKey(),
'title' => $document->getTitle(),
'date' => $document->getAddedDate(),
'documentKey' => $document->getDocumentKey(),
'isPinned' => $document->getIsPinned(),
'isMinutes' => $document->getIsMinutes()
];
}
}
return new Response(json_encode($data));
}
/**
* @Route("/head-office/locker/", name="head-office-locker-post", methods={"POST"})
*
* @param Request $request
* @return Response
*/
public function headOfficePostLockerAction(Request $request, PermissionService $permissionProvider, NotificationService $notificationProvider)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$permissionProvider->checkPermissions('teamHQ', $loggedUser);
if ($request->getContent()) {
$data = json_decode($request->getContent(), true);
$clinic = $loggedUser->getClinic();
$parentFolder = DataObject::getByPath("/Companies/" . $clinic->getName() . "/Locker");
if (!$parentFolder) {
$parentFolder = DataObject\Service::createFolderByPath("/Companies/" . $clinic->getName() . "/Locker");
}
$title = $data['title'];
$documentKey = $data['documentKey'];
$key = $data['documentKey'];
$isPinned = $data['showHighlight'];
$isMinutes = $data['isMinutes'];
$shouldNotify = $data['showNotify'];
$currentDate = date("d/m/Y");
$newObject = new DataObject\LockerDocument();
$newObject->setParent($parentFolder);
$newObject->setTitle($title);
$newObject->setAddedDate($currentDate);
$newObject->setDocumentKey($documentKey);
$newObject->setKey($key);
$newObject->setIsPinned($isPinned);
$newObject->setIsMinutes($isMinutes);
$newObject->setPublished(true);
$newObject->save();
if ($shouldNotify) {
$superuser = $loggedUser->getTypeOfUser() === 'superuser' ? $loggedUser : $clinic->getSuperuser();
$subusers = $superuser->getSubusers();
$allUsers = array(...$subusers, $superuser);
$message = 'A new document "' . $newObject->getTitle() . '" has been uploaded to the {%TeamHQ%}.';
foreach ($allUsers as $user) {
$notificationProvider->createNotification($user, $message, 'team-lounge');
}
}
$response = new Response();
return $response->setContent(json_encode(['message' => 'OK']));
}
return new Response(null);
}
/**
* @Route("/head-office/locker/{id}", name="head-office-locker-delete", methods={"DELETE"})
*
* @param Request $request
* @return Response
*/
public function headOfficeDeleteLockerAction(Request $request, $id, PermissionService $permissionProvider)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$permissionProvider->checkPermissions('teamHQ', $loggedUser);
$practiceDocument = DataObject::getById($id);
if (!is_null($practiceDocument)) {
$practiceDocument->delete();
return new Response('OK', Response::HTTP_OK);
}
throw new BadRequestHttpException();
}
/**
* @Route("/head-office/locker/unpin/{id}", name="head-office-locker-unpin", methods={"PUT"})
*
* @param Request $request
* @return Response
*/
public function headOfficeUnpinLockerAction(Request $request, $id, PermissionService $permissionProvider)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$permissionProvider->checkPermissions('teamHQ', $loggedUser);
$practiceDocument = DataObject::getById($id);
if (!is_null($practiceDocument)) {
$practiceDocument->setIsPinned(false);
$practiceDocument->save();
return new Response('OK', Response::HTTP_OK);
}
throw new BadRequestHttpException();
}
/**
* @Route("/head-office/locker/pin/{id}", name="head-office-locker-pin", methods={"PUT"})
*
* @param Request $request
* @return Response
*/
public function headOfficePinLockerAction(Request $request, $id, PermissionService $permissionProvider)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$permissionProvider->checkPermissions('teamHQ', $loggedUser);
$practiceDocument = DataObject::getById($id);
if (!is_null($practiceDocument)) {
$practiceDocument->setIsPinned(true);
$practiceDocument->save();
return new Response('OK', Response::HTTP_OK);
}
throw new BadRequestHttpException();
}
/**
* @Route("/head-office/team-message/", name="head-office-locker-teammessage-put", methods={"PUT"})
*
* @param Request $request
* @return Response
*/
public function headOfficePutTeamMessageAction(Request $request, PermissionService $permissionProvider)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$permissionProvider->checkPermissions('teamHQ', $loggedUser);
if ($request->getContent()) {
$data = json_decode($request->getContent(), true);
$id = $loggedUser->getId();
$clinic = $loggedUser->getClinic();
$customerMessageArea = $data['customerMessageArea'];
$teamMessageArea = $data['teamMessageArea'];
$clinic->setTeamMessageArea($teamMessageArea);
$clinic->setCustomerMessageArea($customerMessageArea);
$clinic->save();
return new Response('OK', Response::HTTP_OK);
}
}
/**
* @Route("/head-office/team-message/", name="head-office-teammessage-get", methods={"GET"})
*
* @param Request $request
* @return Response
*/
public function headOfficeGetTeamMessageAction(Request $request)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$id = $loggedUser->getId();
$clinic = $loggedUser->getClinic();
$data = [
'customerMessage' => $clinic->getCustomerMessageArea(),
'teamMessage' => $clinic->getTeamMessageArea(),
];
return new Response(json_encode(['messages' => $data]));
}
/**
* @Route("/head-office/our-team/document/request", name="our-team-create-request", methods={"POST"})
*
* @param Request $request
* @return Response
*/
public function headOfficeCreateDocumentRequestAction(Request $request, ToolsService $toolsProvider)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$data = json_decode($request->getContent(), true);
$user = DataObject\Customer::getByID($data['user']);
$toolsProvider->createUserTask($user, $data['description'], 'userDocument');
return new Response('OK', Response::HTTP_OK);
}
/**
* @Route("/head-office/our-team/documents", name="our-team-upload-doc", methods={"POST"})
*
* @param Request $request
* @return Response
*/
public function headOfficeUploadDocumentAction(Request $request, HeadOfficeService $hoService)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$data = json_decode($request->getContent(), true);
if (empty($data['documentKey']) || empty($data['name']) || empty($data['ownerId'])) {
throw new BadRequestHttpException('File and name are required');
}
$owner = DataObject\Customer::getById($data['ownerId']);
$hoService->createUserDocument($data, $owner, $loggedUser);
return new Response('OK', Response::HTTP_OK);
}
/**
* @Route("/head-office/our-team/documents/{id}", name="our-team-delete-doc", methods={"DELETE"})
*
* @param Request $request
* @return Response
*/
public function headOfficeDeleteDocumentAction($id, Request $request, HeadOfficeService $hoService)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
//check if is owner
$doc = DataObject\UserDocument::getById($id);
if (!$doc || $doc->getOwner() !== $loggedUser) {
throw new NotFoundHttpException('Document not found');
}
$doc->delete();
return new Response('OK', Response::HTTP_OK);
}
/**
* This method retrieves users removed from a clinic from the dashboard, the criteria to identify such users is determined
* by active (false), clinic (still part of a clinic), no subscription and no parent user
*
* @Route("/head-office/our-team/users/inactive", name="our-team-get-inactive-users", methods={"GET"})
*
* @param Request $request
* @return Response
*/
public function headOfficeGetInactiveUsersAction(GeneralService $generalProvider, PermissionService $permissionProvider, HeadOfficeService $hoService)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$permissionProvider->checkPermissions('management', $loggedUser);
$clinic = $loggedUser->getClinic();
$inactiveUsers = $hoService->getInactiveClinicUsers($clinic);
$inactiveUsersData = $generalProvider->getUsersData($inactiveUsers);
$response = new Response();
$response->setContent(json_encode(['users' => $inactiveUsersData]));
return $response;
}
/**
* @Route("/head-office/our-team/users/prorata/{contractId}", name="calculate-user-leave", methods={"GET"})
*
* @param Request $request
* @return Response
*/
public function headOfficeGetProRataUserAction(
$contractId,
HeadOfficeService $hoService,
PermissionService $permissionProvider,
Request $request
) {
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$permissionProvider->checkPermissions('management', $loggedUser);
$contract = DataObject\EmployeeContractDetails::getById($contractId);
if (!$contract) {
throw new BadRequestHttpException('Contract not valid');
}
$user = $contract->getUser();
if (!$user) {
throw new BadRequestHttpException('User id not valid');
}
if ($user->getClinic() !== $loggedUser->getClinic()) {
throw new UnauthorizedHttpException('Not authorized');
}
$endDate = $request->query->get('endDate');
if (!$endDate) {
throw new BadRequestHttpException('No end date provided');
}
$prorata = $hoService->getTotalHolidaysProRata($contract, $user, Carbon::parse($endDate));
$response = new Response();
$response->headers->set('Content-Type', 'application/json');
$response->headers->set('Access-Control-Allow-Origin', '*');
$data = [
'prorata' => $prorata
];
$response->setContent(json_encode($data));
return $response;
}
/**
* @Route("/head-office/our-team/users/{userId}", name="our-team-get-user", methods={"GET"})
*
* @param Request $request
* @return Response
*/
public function headOfficeGetUserAction($userId, HeadOfficeService $hoService, PermissionService $permissionProvider)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
//TODO remove comments
//check permission if not getting own info
// if ($userId != $loggedUser->getId()) {
// $permissionProvider->checkPermissions('management', $loggedUser);
// }
$user = DataObject\Customer::getById($userId);
$docs = $hoService->getUserDocs($userId);
$clinic = $loggedUser->getClinic();
$policy = $hoService->getHolidayPolicyData($hoService->getHolidayPolicyByClinic($clinic));
//TODO The contract should be the relevant contract for the period, not specifically the last
$employeeContractDetails = $hoService->getUserLastCreatedContract($user);
$employeeContractDetailsData = $employeeContractDetails
? $hoService->getEmployeeContractDetailsData($employeeContractDetails)
: null;
$workPeriods = $employeeContractDetailsData ? $hoService->getContractWorkPeriods($employeeContractDetails) : [];
$contracts = $hoService->getUserContracts($user);
$contractsData = array_map(function ($contract) use ($hoService) {
$data = $hoService->getEmployeeContractDetailsData($contract);
$data['workPeriods'] = $hoService->getContractWorkPeriods($contract);
return $data;
}, $contracts);
$response = new Response();
$response->headers->set('Content-Type', 'application/json');
$response->headers->set('Access-Control-Allow-Origin', '*');
$data = [
'id' => $userId,
'documents' => $docs,
/* 'clinic policy' => $policy, */
'contractDetails' => $employeeContractDetailsData,
'contracts' => $contractsData,
'workPeriods' => $workPeriods,
'amendments' => $hoService->getAmendmentsByUser($user),
'holidayDetails' => $employeeContractDetailsData
? $hoService->getUserHolidayDetails($user, $hoService->getHolidayPolicyByClinic($user->getClinic())) : null //only retrieves when contract is set
];
$response->setContent(json_encode($data));
return $response;
}
/**
* @Route("/head-office/our-team/users/{userId}/contracts", name="our-team-post-user", methods={"POST"})
*
* @param Request $request
* @return Response
*/
public function headOfficePostUserAction(
$userId,
Request $request,
HeadOfficeService $hoService,
PermissionService $permissionProvider
) {
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
//check permission
$permissionProvider->checkPermissions('management', $loggedUser);
$user = DataObject\Customer::getById($userId);
if (!$user) {
throw new BadRequestHttpException('User id not valid');
}
if ($user->getClinic() !== $loggedUser->getClinic()) {
throw new UnauthorizedHttpException('Not authorized');
}
$payload = json_decode($request->getContent(), true);
$contracts = $hoService->getUserContracts($user);
$lastCreatedContract = $hoService->getUserLastCreatedContract($user);
$contract = $lastCreatedContract;
$today = Carbon::now()->toDateString();
$lastEffectiveDate = $lastCreatedContract ? $lastCreatedContract->getEffectiveDate() : null;
//if the last saved contract is today, we just update it, do not create a new contract
if (!$lastEffectiveDate || $lastEffectiveDate->toDateString() != $today) {
$contract = $hoService->createEmployeeContractDetails($user);
}
if ($lastCreatedContract) {
$payload['hiringDate'] = $lastCreatedContract->getHiringDate();
} else {
$payload['hiringDate'] = Carbon::parse($payload['hiringDate']);
}
$hoService->updateEmployeeContractDetails($payload, $contract);
$hoService->saveWorkPeriods($payload['workPeriods'], $contract);
$response = new Response();
$response->headers->set('Content-Type', 'application/json');
$response->headers->set('Access-Control-Allow-Origin', '*');
return $response->setContent(json_encode(['id' => $contract->getId()]));
}
/**
* @Route("/head-office/our-team/users/{userId}/contracts/{contractId}", name="our-team-put-user", methods={"PUT"})
*
* @param Request $request
* @return Response
*/
public function headOfficePutUserAction($userId, $contractId, Request $request, HeadOfficeService $hoService, PermissionService $permissionProvider)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
//check permission
$permissionProvider->checkPermissions('management', $loggedUser);
$user = DataObject\Customer::getById($userId);
$contract = DataObject\EmployeeContractDetails::getById($contractId);
if (!$user || !$contract || $contract->getUser()->getId() != $user->getId()) {
throw new BadRequestHttpException('Contract not found');
}
if ($user->getClinic() !== $loggedUser->getClinic()) {
throw new UnauthorizedHttpException('Not authorized');
}
$payload = json_decode($request->getContent(), true);
if (isset($payload['workPeriods'])) {
$hoService->saveWorkPeriods($payload['workPeriods'], $contract);
}
if (isset($payload['reportTo'])) {
$hoService->updateContractReportTo($contract, $payload['reportTo']);
$contract->save();
}
if (!empty($payload['endDate'])) {
$hoService->updateContractEndDate($contract, $payload['endDate']);
}
return new Response('OK', Response::HTTP_OK);
}
/**
* @Route("/head-office/our-team/users/history/{userId}", name="our-team-get-user-history", methods={"GET"})
*
* @param Request $request
* @return Response
*/
public function headOfficeGetUserHolidayHistoryAction(
$userId,
HeadOfficeService $hoService,
PermissionService $permissionProvider,
Request $request
) {
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
//check permission if not getting own info
if ($userId != $loggedUser->getId()) {
$permissionProvider->checkPermissions('management', $loggedUser);
}
$user = DataObject\Customer::getById($userId);
if (!$user) {
throw new BadRequestHttpException('User id not valid');
}
if ($user->getClinic() !== $loggedUser->getClinic()) {
throw new UnauthorizedHttpException('Not authorized');
}
$yearAgo = (int)$request->query->get('year');
if (!$yearAgo) {
$yearAgo = 1;
}
[$events, $limit, $yearAgo] = $hoService->getUserHolidaysEvents($user, $yearAgo);
$response = new Response();
$response->headers->set('Content-Type', 'application/json');
$response->headers->set('Access-Control-Allow-Origin', '*');
$response->setContent(json_encode(['history' => $events, 'limit' => $limit, 'year' => $yearAgo]));
return $response;
}
/**
* @Route("/head-office/our-team/policies", name="create-our-team-policies", methods={"POST"})
*
* @param Request $request
* @return Response
*/
public function headOfficeCreatePolicyAction(Request $request, PermissionService $permissionProvider, HeadOfficeService $hoService)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
//check permission
$permissionProvider->checkPermissions('management', $loggedUser);
$clinic = $loggedUser->getClinic();
$policy = $hoService->createOrUpdateHolidayPolicy(json_decode($request->getContent(), true), $clinic);
$clinic->setHolidayPolicy($policy);
$clinic->save();
return new Response('OK', Response::HTTP_OK);
}
/**
* @Route("/head-office/our-team/policies", name="get-our-team-policies", methods={"GET"})
*
* @param Request $request
* @return Response
*/
public function headOfficeGetPolicyAction(PermissionService $permissionProvider, HeadOfficeService $hoService)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$clinic = $loggedUser->getClinic();
$policy = $hoService->getHolidayPolicyData($hoService->getHolidayPolicyByClinic($clinic));
$response = new Response();
$response->headers->set('Content-Type', 'application/json');
$response->headers->set('Access-Control-Allow-Origin', '*');
$response->setContent(json_encode(['policy' => $policy]));
return $response;
}
/**
* @Route("/head-office/our-team/policies/{id}", name="update-our-team-policies", methods={"PUT"})
*
* @param Request $request
* @return Response
*/
public function headOfficeUpdatePolicyAction($id, Request $request, PermissionService $permissionProvider, HeadOfficeService $hoService, GeneralService $generalProvider)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
//check permission
$permissionProvider->checkPermissions('management', $loggedUser);
$clinic = $loggedUser->getClinic();
//check ownership
if ($hoService->getHolidayPolicyByClinic($clinic)->getId() != $id) {
throw new UnauthorizedHttpException('Not allowed');
}
$policy = $hoService->createOrUpdateHolidayPolicy(json_decode($request->getContent(), true), $clinic, $id);
$clinic->setHolidayPolicy($policy);
return new Response('OK', Response::HTTP_OK);
}
/**
* @Route("/head-office/our-team/holiday-enrollment", name="get-our-team-holiday-enrollment", methods={"GET"})
*
* @param Request $request
* @return Response
*/
public function headOfficeGetEnrollmentsAction(PermissionService $permissionProvider, HeadOfficeService $hoService, GeneralService $generalProvider)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
//check permission
$permissionProvider->checkPermissions('management', $loggedUser);
$clinic = $loggedUser->getClinic();
$allsetUsers = $hoService->getClinicHolidayEnrolledUsers($clinic);
$data = [];
foreach ($allsetUsers as $user) {
$data[] = $generalProvider->getUserData($user);
}
$response = new Response();
$response->headers->set('Content-Type', 'application/json');
$response->headers->set('Access-Control-Allow-Origin', '*');
$response->setContent(json_encode(['users' => $data]));
return $response;
}
/**
* @Route("/head-office/our-team/amendments/{userId}", name="create-holiday-amendment", methods={"POST"})
*
* @param Request $request
* @return Response
*/
public function headOfficeCreateAmendmentAction(
$userId,
Request $request,
PermissionService $permissionProvider,
HeadOfficeService $hoService,
EventDispatcherInterface $dispatcher,
) {
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
//check permission
$permissionProvider->checkPermissions('management', $loggedUser);
$user = DataObject\Customer::getById($userId);
if (!$user) {
throw new BadRequestHttpException('User id not valid');
}
if ($user->getClinic() !== $loggedUser->getClinic()) {
throw new UnauthorizedHttpException('Not authorized');
}
$employeeContractDetails = $hoService->getUserLastCreatedContract($user);
if (!$employeeContractDetails) {
throw new BadRequestHttpException('Employee contract is not set');
}
$payload = json_decode($request->getContent(), true);
$payload['adjustmentBase'] = $hoService->getHolidayPolicyByClinic($user->getClinic())->getHolidayEntitlementBase();
$amendment = $hoService->createHolidayAmendment($user, $payload, $loggedUser);
$amendmentDetails = $hoService->getAmendmentDetails($amendment);
$msg = $hoService->createHolidayMessage('amendmentCreated', $amendmentDetails);
//create a new event to notify
$event = new HolidayEvent([
'recipients' => [$amendment->getEmployee()],
'msg' => $msg,
'id' => $userId
]);
$dispatcher->dispatch($event, 'holiday.onAmendmentCreated');
return new Response('OK', Response::HTTP_OK);
}
/**
* @Route("/head-office/our-team/requests/{userId}", name="create-holiday-request", methods={"POST"})
*
* @param Request $request
* @return Response
*/
public function headOfficeCreateHolidayRequestAction(
$userId,
Request $request,
HeadOfficeService $hoService,
EventDispatcherInterface $dispatcher,
) {
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$user = DataObject\Customer::getById($userId);
if (!$user) {
throw new UnauthorizedHttpException('User id not valid');
}
if ($user->getClinic() !== $loggedUser->getClinic()) {
throw new UnauthorizedHttpException('Not authorized');
}
$policy = $hoService->getHolidayPolicyByClinic($user->getClinic());
$payload = json_decode($request->getContent(), true);
$type = $payload['type'];
//check if request includes a bank holiday
$startDate = Carbon::parse($payload['start']);
$endDate = $type === 'days' ? Carbon::parse($payload['end']) : $startDate->clone();
$hours = $payload['hours'];
$intersectBankHolidays = $hoService->getBankHolidaysFromInterval($startDate, $endDate, $policy->getApplicableBankHoliday());
$processedRequests = $hoService->separateRequestsByBankHolidays($intersectBankHolidays, $startDate, $endDate, $type);
$contract = $hoService->getUserLastCreatedContract($user);
$holidayEntitlementType = $policy->getHolidayEntitlementBase();
// if holiday entitlement is based in hours and type is period, should add hours to processed request
if ($holidayEntitlementType === 'hours' && $type === 'period') {
$processedRequests = array_map(function ($req) use ($hours) {
$req['hours'] = $hours;
return $req;
}, $processedRequests);
}
//check clinic policy to see if holidays cannot be negative
if (!$policy->getHolidayCounterNegative() && $payload['category'] == 'holiday') {
$exceedsAvailable = $hoService->checkRequestsExceedAvailableHolidays($user, $processedRequests);
if ($exceedsAvailable) {
throw new BadRequestHttpException('Your request period exceeds holidays available.');
}
}
foreach ($processedRequests as $processedRequest) {
$data = [
'start' => $processedRequest['start'],
'end' => $processedRequest['end'],
'type' => $processedRequest['type'],
'description' => $payload['description'],
'category' => $payload['category'],
'period' => !empty($payload['category']) ? $payload['category'] : '',
'hours' => !empty($processedRequest['hours']) ? $processedRequest['hours'] : ''
];
$request = $hoService->createHolidayRequest($user, $data, $loggedUser);
$requestDetails = $hoService->getHolidayRequestDetails('requestCreated', $request, $holidayEntitlementType === 'hours');
$msg = $hoService->createHolidayMessage('requestCreated', $requestDetails);
//create a new event to notify
$event = new HolidayEvent([
'recipients' => $contract->getReportTo(),
'msg' => $msg,
'id' => $userId
]);
$dispatcher->dispatch($event, 'holiday.onRequestCreated');
}
return new Response('OK', Response::HTTP_OK);
}
/**
* @Route("/head-office/our-team/requests/{id}", name="update-holiday-request", methods={"PUT"})
*
* @param Request $request
* @return Response
*/
public function headOfficeUpdateRequestAction(
$id,
Request $request,
HeadOfficeService $hoService,
EventDispatcherInterface $dispatcher,
) {
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$holidayRequest = DataObject\HolidayRequest::getById($id);
$employee = $holidayRequest->getEmployee();
$contract = $hoService->getUserLastCreatedContract($employee);
$reportedUsers = $contract->getReportTo();
//only users or the person who the user reports to are able to update
if (!$holidayRequest || ($employee != $loggedUser && !in_array($loggedUser, $reportedUsers))) {
throw new BadRequestHttpException('Request not found');
}
$payload = json_decode($request->getContent(), true);
//approvals are only updated by reported user
if (in_array($loggedUser, $reportedUsers) && isset($payload['approved'])) {
$status = $payload['approved'] ? 'approved' : 'rejected';
$hoService->updateHolidayRequestStatus(
$holidayRequest,
$holidayRequest->getStatus(),
$status,
$loggedUser,
$payload['rejectReason']
);
}
$holidayRequest->save();
$eventType = $holidayRequest->getStatus() === 'approved'
? 'requestAccepted' : ($holidayRequest->getStatus() === 'rejected' ? 'requestRejected' : null);
if ($eventType) {
$policy = $hoService->getHolidayPolicyByClinic($employee->getClinic());
$holidayEntitlementType = $policy->getHolidayEntitlementBase();
$requestDetails = $hoService->getHolidayRequestDetails($eventType, $holidayRequest, $holidayEntitlementType === 'hours');
$msg = $hoService->createHolidayMessage($eventType, $requestDetails);
//create a new event to notify
$event = new HolidayEvent([
'recipients' => [$holidayRequest->getEmployee()],
'msg' => $msg,
'id' => $employee->getId()
]);
$dispatcher->dispatch($event, 'holiday.on' . ucfirst($eventType));
}
return new Response('OK', Response::HTTP_OK);
}
/**
* @Route("/head-office/our-team/requests/{id}", name="delete-holiday-request", methods={"DELETE"})
*
* @param Request $request
* @return Response
*/
public function headOfficeDeleteRequestAction($id)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$holidayRequest = DataObject\HolidayRequest::getById($id);
$employee = $holidayRequest->getEmployee();
//only owners can delete their own requests
if (!$holidayRequest || $employee != $loggedUser) {
throw new BadRequestHttpException('Request not found');
}
$today = Carbon::now();
$requestStart = Carbon::parse($holidayRequest->getStart());
if ($today->gt($requestStart)) {
throw new BadRequestHttpException('It is a past request');
}
$holidayRequest->delete();
return new Response('OK', Response::HTTP_OK);
}
/**
* @Route("/head-office/our-team/requests", name="create-multiple-holiday-request", methods={"POST"})
*
* @param Request $request
* @return Response
*/
public function headOfficeCreateMultipleHolidaysRequestAction(
Request $request,
HeadOfficeService $hoService,
EventDispatcherInterface $dispatcher,
PermissionService $permissionProvider
) {
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$permissionProvider->checkPermissions('management', $loggedUser);
$policy = $hoService->getHolidayPolicyByClinic($loggedUser->getClinic());
$payload = json_decode($request->getContent(), true);
$type = "days";
//check if request includes a bank holiday
$startDate = Carbon::parse($payload['start']);
$endDate = Carbon::parse($payload['end']);
$intersectBankHolidays = $hoService->getBankHolidaysFromInterval($startDate, $endDate, $policy->getApplicableBankHoliday());
$processedRequests = $hoService->separateRequestsByBankHolidays($intersectBankHolidays, $startDate, $endDate, $type);
foreach ($payload['users'] as $userId => $shouldCreate) {
$user = DataObject\Customer::getById($userId);
if (!$shouldCreate || $user->getClinic() !== $loggedUser->getClinic()) {
continue;
}
$contract = $hoService->getUserLastCreatedContract($user);
$holidayEntitlementType = $policy->getHolidayEntitlementBase();
foreach ($processedRequests as $processedRequest) {
$data = [
'start' => $processedRequest['start'],
'end' => $processedRequest['end'],
'type' => $processedRequest['type'],
'description' => $payload['description'],
'category' => 'holiday'
];
$request = $hoService->createHolidayRequest($user, $data, $loggedUser);
$request->setStatus('approved'); //it's approved straight away
$request->save();
$requestDetails = $hoService->getHolidayRequestDetails('requestCreated', $request, $holidayEntitlementType === 'hours');
$msg = $hoService->createHolidayMessage('requestCreated', $requestDetails);
//create a new event to notify
$event = new HolidayEvent([
'recipients' => $contract->getReportTo(),
'msg' => $msg,
'id' => $userId
]);
$dispatcher->dispatch($event, 'holiday.onRequestCreated');
}
}
return new Response('OK', Response::HTTP_OK);
}
/**
* @Route("/head-office/our-team/leaves", name="get-clinic-leaves", methods={"GET"})
*
* @param Request $request
* @return Response
*/
public function headOfficeClinicLeavesAction(HeadOfficeService $hoService, PermissionService $permissionProvider, GeneralService $generalProvider)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$teamUsers = [];
if ($loggedUser->getTypeOfUser() == 'subuser') {
$teamUsers = [$loggedUser];
} else {
$teamUsers = $hoService->getReporteesByManager($loggedUser);
}
$policy = $hoService->getHolidayPolicyByClinic($loggedUser->getClinic());
$leaves = $hoService->getReporteeLeaves($teamUsers, $policy->getHolidayEntitlementBase());
$response = new Response();
$response->headers->set('Content-Type', 'application/json');
$response->headers->set('Access-Control-Allow-Origin', '*');
$response->setContent(json_encode(['teamLeaves' => $leaves, 'reportees' => $generalProvider->getUsersData(array_unique($teamUsers))]));
return $response;
}
/**
* @Route("/head-office/our-team/bank-holidays", name="get-bank-holidays", methods={"GET"})
*
* @param Request $request
* @return Response
*/
public function headOfficeGetBankHolidaysAction(HeadOfficeService $hoService)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$bankHolidays = $hoService->getBankHolidaysFromClinic($loggedUser->getClinic());
$response = new Response();
$response->headers->set('Content-Type', 'application/json');
$response->headers->set('Access-Control-Allow-Origin', '*');
$response->setContent(json_encode(['bankHolidays' => $bankHolidays]));
return $response;
}
/**
* @Route("/head-office/our-team/leaver-wizard", name="create-leave", methods={"POST"})
*/
public function createLeaveAction(Request $request, HeadOfficeService $hoService, PermissionService $permissionProvider)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$permissionProvider->checkPermissions('management', $loggedUser);
$payload = json_decode($request->getContent(), true);
//any validation
$hoService->createLeaveWizardInfo($payload, $loggedUser);
return new Response('OK', Response::HTTP_OK);
}
/**
* @Route("/head-office/our-team/leaver-wizard/{userId}", name="get-leave", methods={"GET"})
*/
public function getLeaveAction($userId, Request $request, HeadOfficeService $hoService, PermissionService $permissionProvider)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
//any validation
$data = $hoService->getLeavingWizardInfoByUserid($userId);
$response = new Response();
$response->headers->set('Content-Type', 'application/json');
$response->headers->set('Access-Control-Allow-Origin', '*');
$response->setContent(json_encode(['leavingWizardInfo' => $data]));
return $response;
}
/**
* @Route("/education/courses", name="education-courses-read")
*/
public function educationCourseReadAction()
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$entries = new DataObject\Course\Listing();
$entries->load();
$entries = $entries->getData();
$data = [];
foreach ($entries as $course) {
$modules = [];
foreach ($course->getModules()->getItems() as $module) {
$units = [];
foreach ($module->getUnits() as $unit) {
$video = $unit->getVideo();
/* $videoDuration = ($video && $video->getData()) ? $video->getData()->getCustomSettings()['embeddedMetaData']['Duration'] : ''; */
$units[] = [
'name' => $unit->getName(),
'id' => $unit->getId(),
'number' => $unit->getNumber(),
'quiz' => $unit->getHasQuiz(),
'description' => $unit->getDescription(),
'videoDuration' => ''
];
}
$modules[] = [
'name' => $module->getName(),
'number' => $module->getNumber(),
'units' => $units
];
}
$cardImage = $course->getCardImage();
$cardThumbnail = ($cardImage) ? $cardImage->getThumbnail('courseCard')->getPath() : null;
$listImage = $course->getListImage();
$listThumbnail = ($listImage) ? $listImage->getThumbnail('newsList')->getPath() : null;
$data[] = [
'name' => $course->getName(),
'id' => $course->getId(),
'provider' => $course->getProvider(),
'instructor' => $course->getInstructor(),
'cardImage' => $cardThumbnail,
'listImage' => $listThumbnail,
'modules' => $modules,
'description' => $course->getDescription()
];
}
$response = new Response();
$response->headers->set('Content-Type', 'application/json');
$response->headers->set('Access-Control-Allow-Origin', '*');
$response->setContent(json_encode($data));
return $response;
}
/**
* @Route("/education/courses/getting-started", name="education-courses-getting-started", methods={"GET"})
*/
public function educationGettingStartedReadAction()
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$page = DataObject\GettingStartedPageEducation::getById(2316);
$data = [];
$banner = [];
$mainCourseLinks = [];
foreach ($page->getCoursesLink() as $courseLink) {
array_push($mainCourseLinks, $courseLink->getId());
};
$banner['title'] = $page->getTitle();
$banner['text'] = $page->getText();
$banner['background'] = $page->getBackground()->getThumbnail('heroGrid')->getPath();
$banner['newCourse'] = $page->getNewCourse();
$banner['courseLink'] = $mainCourseLinks;
$featuredCourses = [];
foreach ($page->getFeaturedCourse() as $course) {
$featuredCourses[] = [
'title' => $course['title']->getData(),
'text' => $course['text']->getData(),
'image' => $course['image']->getData()->getThumbnail('standardTeaser')->getPath(),
'link' => $course['courseLink']->getData()->getId(),
];
}
$data['banner'] = $banner;
$data['featuredCourses'] = $featuredCourses;
$response = new Response();
$response->headers->set('Content-Type', 'application/json');
$response->headers->set('Access-Control-Allow-Origin', '*');
$response->setContent(json_encode($data));
return $response;
}
/**
* @Route("/education/courses/{unitId}", name="education-read", methods={"GET"})
*/
public function educationUnitReadAction($unitId)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$unit = DataObject\CourseUnit::getById($unitId);
$quiz = [];
if ($unit->getHasQuiz()) {
if ($unit->getQuestions()) {
foreach ($unit->getQuestions()->getItems() as $question) {
$answers = [];
foreach ($question->getAnswer() as $answer) {
$answers[] = $answer['possibleAnswer']->getData();
}
$quiz[] = [
'question' => $question->getQuestion(),
'id' => $question->getIndex(),
'answers' => $answers
];
}
}
} else {
$quiz = null;
}
$video = $unit->getVideo();
$videoPath = ($video) ? $video->getData()->getPath() : '';
$videoName = ($video) ? $video->getData()->getFilename() : '';
$data = [
'name' => $unit->getName(),
'id' => $unit->getId(),
'number' => $unit->getNumber(),
'quiz' => $quiz,
'description' => $unit->getDescription(),
'video' => $videoPath . $videoName,
'resources' => $unit->getResources()
];
$response = new Response();
$response->headers->set('Content-Type', 'application/json');
$response->headers->set('Access-Control-Allow-Origin', '*');
$response->setContent(json_encode($data));
return $response;
}
/**
* @Route("/education/courses/{courseId}", name="add-my-course", methods={"POST"})
*/
public function addMyCourseAction($courseId, Request $request)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$id = $loggedUser->getId();
$currentCourses = $loggedUser->getMyCourses();
if ($request->getContent()) {
$data = json_decode($request->getContent(), true);
$courses = $data['courses'];
$coursesToAdd = [];
foreach ($courses as $courseItem) {
$course = DataObject\Course::getById($courseItem);
if (!$course) {
return new Response('Bad Request');
}
if (!in_array($course, $currentCourses)) {
array_push($coursesToAdd, $course);
}
}
$loggedUser->setMyCourses(array_merge($currentCourses, $coursesToAdd));
} else {
$course = DataObject\Course::getById($courseId);
if (!$course) {
return new Response('Bad Request');
}
$loggedUser->setMyCourses(array_merge($currentCourses, [$course]));
}
$loggedUser->save();
return new Response('OK', Response::HTTP_OK);
}
/**
* @Route("/education/courses/{courseId}", name="remove-my-course", methods={"DELETE"})
*/
public function removeMyCourseAction($courseId, Request $request)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$currentCourses = $loggedUser->getMyCourses();
if ($request->getContent()) {
$data = json_decode($request->getContent(), true);
$courses = $data['courses'];
$currentCourses = array_filter($currentCourses, function ($currentCourse) use ($courses) {
if (!in_array($currentCourse->getId(), $courses)) {
return true;
};
return false;
});
$loggedUser->setMyCourses(array_merge($currentCourses));
} else {
$course = DataObject\Course::getById($courseId);
if (!$course) {
return new Response('Bad Request');
}
$currentCourses = array_filter($currentCourses, function ($course) use ($courseId) {
return ($course->getId() != $courseId);
});
$loggedUser->setMyCourses(array_merge($currentCourses));
}
$loggedUser->save();
return new Response('OK', Response::HTTP_OK);
}
/**
* @Route("/education/users", name="education-users-read")
*/
public function educationUsersReadAction()
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$data = [];
$modules = [];
$courses = $loggedUser->getMyCourses();
$myCourses = [];
foreach ($courses as $course) {
$myCourses[] = [
'id' => $course->getId(),
];
}
$log = [];
if ($loggedUser->getCourse()) {
foreach ($loggedUser->getCourse()->getItems() as $course) {
$courseModule = $course->getmodule();
$modules = [];
foreach ($courseModule as $module) {
$units = [];
foreach ($module['units']->getData() as $unit) {
$units[] = [
'id' => intval($unit[0]),
'number' => intval($unit[1]),
'quiz' => $unit[2],
'quizCompleted' => $unit[3],
];
}
$modules[] = [
'number' => $module['moduleNumber']->getData(),
'units' => $units
];
}
$log[] = [
'name' => $course->getName(),
'id' => $course->getCourseId(),
'modules' => $modules,
];
}
}
$data['log'] = $log;
$data['myCourses'] = $myCourses;
$response = new Response();
$response->headers->set('Content-Type', 'application/json');
$response->headers->set('Access-Control-Allow-Origin', '*');
$response->setContent(json_encode($data));
return $response;
}
/**
* @Route("/education/quiz/{unitId}", name="education-quiz-post", methods={"POST"})
*
* @param Request $request
* @return Response
*/
public function educationQuizCheckAction(Request $request, $unitId)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$id = $loggedUser->getId();
if ($request->getContent()) {
$data = json_decode($request->getContent(), true);
$answersEncoded = $data['answers'];
$answers = json_decode($answersEncoded, true);
$unit = DataObject\CourseUnit::getById($unitId);
$questions = $unit->getQuestions()->getItems();
$correctAnswers = 0;
foreach ($questions as $question) {
/* $correctAnswers[] = [
'qIndex'=> $question->getIndex(),
'currAnswer'=>$answers['0']
]; */
$correct = preg_replace('/\s+/', '', $question->getRightAnswer());
$answer = preg_replace('/\s+/', '', $answers[strval($question->getIndex())]);
if ($answer === $correct) {
$correctAnswers++;
}
}
$response = new Response();
$response->headers->set('Content-Type', 'application/json');
$response->headers->set('Access-Control-Allow-Origin', '*');
$response->setContent($correctAnswers);
return $response;
}
return new Response(null);
}
/**
* @Route("/education/users/{unitId}", name="education-users-post", methods={"POST"})
*
* @param Request $request
* @return Response
*/
public function educationUsersPostAction(Request $request, $unitId)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$id = $loggedUser->getId();
if ($request->getContent()) {
$data = json_decode($request->getContent(), true);
$courseName = $data['courseName'];
$courseId = $data['courseId'];
$moduleNumber = $data['moduleNumber'];
$completedQuiz = $data['completedQuiz'];
$unit = DataObject\CourseUnit::getById($unitId);
$courseLog = $loggedUser->getCourse();
$hasQuiz = !empty($unit->getQuestions());
$moduleQuiz = $unit->getModuleQuiz();
if (!is_null($courseLog)) {
$courseLog = $loggedUser->getCourse()->getItems();
$currentCourse = array_filter($courseLog, function ($course) use ($courseId) {
return ($course->getCourseId() == $courseId);
});
if (!empty($currentCourse)) {
$courseIndex = key($currentCourse);
$modules = $currentCourse[$courseIndex]->getModule();
$currentModule = array_filter($modules, function ($module) use ($moduleNumber) {
return ($module['moduleNumber']->getData() == $moduleNumber);
});
if (!empty($currentModule)) {
$moduleIndex = key($currentModule);
$currentUnits = $currentModule[$moduleIndex]['units']->getData();
if ($completedQuiz == true) {
if ($moduleQuiz) {
$currentModule[$moduleIndex]['units']->setData([...$currentUnits, [$unit->getId(), $unit->getNumber(), $hasQuiz, true]]);
$loggedUser->save();
return new Response('OK', Response::HTTP_OK);
}
}
$currentModule[$moduleIndex]['units']->setData([...$currentUnits, [$unit->getId(), $unit->getNumber(), $hasQuiz, boolval($completedQuiz)]]);
$loggedUser->save();
} else {
$blockData = [
"moduleNumber" => new BlockElement('moduleNumber', 'numeric', $moduleNumber),
"units" => new BlockElement('units', 'table', [[$unit->getId(), $unit->getNumber(), $hasQuiz, $moduleQuiz ? boolval($moduleQuiz) : boolval($completedQuiz)]])
];
$currentCourse[0]->setModule(array_merge($modules, [$blockData]));
$loggedUser->save();
}
} else {
$newCourse = new DataObject\Fieldcollection\Data\CourseUserLog();
$newCourse->setName($courseName);
$newCourse->setCourseId($courseId);
$blockData = [
"moduleNumber" => new BlockElement('moduleNumber', 'numeric', $moduleNumber),
"units" => new BlockElement('units', 'table', [[$unit->getId(), $unit->getNumber(), $hasQuiz, $moduleQuiz ? boolval($moduleQuiz) : boolval($completedQuiz)]])
];
$newCourse->setModule([$blockData]);
$loggedUser->getCourse()->setItems(array_merge($courseLog, [$newCourse]));
$loggedUser->save();
}
} else {
$newCourse = new DataObject\Fieldcollection\Data\CourseUserLog();
$newCourse->setName($courseName);
$newCourse->setCourseId($courseId);
$blockData = [
"moduleNumber" => new BlockElement('moduleNumber', 'numeric', $moduleNumber),
"units" => new BlockElement('units', 'table', [[$unit->getId(), $unit->getNumber(), $hasQuiz, $moduleQuiz ? boolval($moduleQuiz) : boolval($completedQuiz)]])
];
$newCourse->setModule([$blockData]);
$courses = new DataObject\Fieldcollection();
$courses->add($newCourse);
$loggedUser->setCourse($courses);
$loggedUser->save();
}
return new Response('OK', Response::HTTP_OK);
}
return new Response(null);
}
/**
* @Route("/dashboard/credentials", name="dashboard-credentials-get", methods={"GET"})
*/
public function dashboardGetCredentialsAction(GeneralService $generalProvider, PermissionService $permissionProvider)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$permissionProvider->checkPermissions('management', $loggedUser);
$super = $permissionProvider->getSuperuser($loggedUser);
$allUsers = $super->getSubusers();
if ($loggedUser->getTypeOfUser() !== 'superuser') {
$allUsers = array_merge($allUsers, [$loggedUser->getClinic()->getSuperuser()]);
}
$users = $generalProvider->getUsersData($allUsers);
$subscriptionsData = $this->filterIncludedSubscriptions($super);
$includedSubsTotal = count($subscriptionsData['includedSubs']);
$includedSubsNotUsed = count($subscriptionsData['includedSubs']) - count($subscriptionsData['includedSubsNotUsed']);
if ($super->getSubscription()->getIsTrycareMembership()) {
$includedSubsTotal = TrycareMembership::getAdditionalSubscriptionsAmount($super->getSubscription()->getTrycareMemberId());
$includedSubsNotUsed = $includedSubsTotal - count($subscriptionsData['includedSubs']);
}
$userData = [];
$userData = [
'subusers' => $users,
'role' => $loggedUser->getTypeOfUser(),
'includedSubTotal' => $includedSubsTotal,
'includedSubUsed' => $includedSubsNotUsed
];
$response = new Response();
$response->headers->set('Content-Type', 'application/json');
$response->headers->set('Access-Control-Allow-Origin', '*');
$response->setContent(json_encode($userData));
return $response;
}
/**
* @Route("/dashboard/credentials", name="dashboard-credentials-change", methods={"PUT"})
*/
public function dashboardUpdateCredentialsAction(Request $request)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$content = json_decode($request->getContent());
$form = $this->createForm(PasswordFormType::class);
$form->submit((array)$content);
if (!$form->isValid()) {
$errors = [];
foreach ($form->getErrors(deep: true, flatten: true) as $error) {
$propertyName = $error->getOrigin()->getName();
$errors[] = $error->getMessage();
}
throw new BadRequestHttpException(json_encode($errors));
}
$plainPass = $form->getData()['password'];
$loggedUser->setPassword($plainPass);
$loggedUser->save();
return new Response(json_encode($plainPass), Response::HTTP_OK);
}
public function filterIncludedSubscriptions($loggedUser)
{
$includedSubscriptions = $loggedUser->getIncludedSubscriptions();
$includedSubsNotUsed = [];
foreach ($includedSubscriptions as $sub) {
$user = $sub->getUser();
if (empty($user)) {
$includedSubsNotUsed[] = $sub;
}
}
return [
'includedSubs' => $includedSubscriptions,
'includedSubsNotUsed' => $includedSubsNotUsed
];
}
/**
* @Route("/dashboard/user", name="dashboard-user-create", methods={"POST"})
*/
public function dashboardCreateUserAction(Request $request, UserHandler $userHandler, PermissionService $permissionProvider)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$permissionProvider->checkPermissions('management', $loggedUser);
$clinic = $loggedUser->getClinic();
if (is_null($clinic)) {
throw new BadRequestHttpException('No clinic ID registered.');
}
$superuser = $clinic->getSuperuser();
$content = json_decode($request->getContent());
$form = $this->createForm(ManageUserCreateType::class);
$form->submit((array)$content);
if (!$form->isValid()) {
$errors = [];
foreach ($form->getErrors(deep: true, flatten: true) as $error) {
$errors[] = $error->getMessage();
}
throw new BadRequestHttpException(json_encode($errors));
}
$payload = json_decode($request->getContent(), true);
$response = new Response();
$stripeResponse = $userHandler->addOneExtraLicence($superuser, $payload);
return $response->setContent(json_encode($stripeResponse));
}
/**
* @Route("/dashboard/users", name="dashboard-users-create", methods={"POST"})
*/
public function dashboardCreateUsersAction(
Request $request,
UserHandler $userHandler,
PermissionService $permissionProvider,
FreeTrialService $freeTrialService,
TrycareService $trycareService
) {
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$permissionProvider->checkPermissions('manager', $loggedUser);
$clinic = $loggedUser->getClinic();
if (is_null($clinic)) {
throw new BadRequestHttpException('No clinic ID registered.');
}
$data = json_decode($request->getContent());
$userBlocks = $data->userBlocks;
foreach ($userBlocks as $block) {
$form = $this->createForm(ManageUserCreateType::class);
$userHandler->validateUsersInputs($block, $form);
}
$superuser = $clinic->getSuperuser();
$includedSubsResult = [];
$stripeResponse = [];
$response = new Response();
//if superuser is free trial. create new included subs for additional users.
if ($superuser->getSubscription()->getIsFreeTrial()) {
$freeTrialService->createFreeTrialSubusers($userBlocks, $superuser);
$includedSubsResult = ['status' => 'OK'];
return $response->setContent(json_encode(['stripe' => $stripeResponse, 'included' => $includedSubsResult]));
}
$isTrycareSubscription = $superuser->getSubscription()->getIsTrycareMembership();
// is trycare sub, we need to check if users to add do not exceed available add subs
if ($isTrycareSubscription) {
$maxSubs = TrycareMembership::getAdditionalSubscriptionsAmount($superuser->getSubscription()->getTrycareMemberId());
$subsInUse = $superuser->getIncludedSubscriptions();
if (count($subsInUse) >= $maxSubs) {
throw new BadRequestHttpException('No aditional user subscriptions available. Please contact support.');
}
$trycareService->createTrycareSubusers($userBlocks, $superuser);
$includedSubsResult = ['status' => 'OK'];
return $response->setContent(json_encode(['stripe' => $stripeResponse, 'included' => $includedSubsResult]));
}
$emptyIncludedSubscriptions = array_values($userHandler->getFreeIncludedSubscriptions($superuser));
if (count($emptyIncludedSubscriptions) > 0) {
$includedUserBlocks = array_splice($userBlocks, 0, count($emptyIncludedSubscriptions));
$customers = $userHandler->createSubusersFromBlocks($includedUserBlocks, $superuser);
foreach ($customers as $index => $customer) {
$customerId = $customer->getId();
$userHandler->attachCustomerToSubscription(
$emptyIncludedSubscriptions[$index],
$customer,
' is being attached a customer',
"customer ID: $customerId"
);
}
$superuser->setSubusers([...$superuser->getSubusers(), ...$customers]);
$superuser->save();
$includedSubsResult = ['status' => 'OK'];
}
//if there are still users in the block means that the number of included subscriptions available wasn't enough
if (count($userBlocks) > 0 && !$isTrycareSubscription) {
$stripeResponse = $userHandler->addExtraLicences($superuser, count($userBlocks), $userBlocks);
}
return $response->setContent(json_encode(['stripe' => $stripeResponse, 'included' => $includedSubsResult]));
}
/**
* @Route("/dashboard/user/{id}", name="dashboard-users-delete", methods={"DELETE"})
*/
public function dashboardDeleteUserAction($id, Request $request, CustomerProviderInterface $customerProvider, PermissionService $permissionProvider, UserHandler $userHandler)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$permissionProvider->checkPermissions('management', $loggedUser);
$user = $customerProvider->getById($id);
if ($user->getTypeOfUser() === 'superuser') {
throw new BadRequestHttpException('Superusers cannot be deleted');
}
$userClinic = $user->getClinic();
$loggedUserClinic = $loggedUser->getClinic();
if (is_null($userClinic) || is_null($loggedUserClinic)) {
throw new BadRequestHttpException('No clinic ID registered.');
}
if ($userClinic->getId() !== $loggedUserClinic->getId()) {
throw new BadRequestHttpException('You can only unsubscribe a user from your practice.');
}
$superuser = $userClinic->getSuperuser();
$userHandler->handleSubuserRemoval($user, $superuser);
$response = new Response();
return $response->setContent(json_encode(['message' => 'OK']));
}
/**
* @Route("/dashboard/user/{id}", name="dashboard-users-update", methods={"PUT"})
*/
public function dashboardUpdateUserAction($id, Request $request, CustomerProviderInterface $customerProvider, PermissionService $permissionProvider)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$permissionProvider->checkPermissions('management', $loggedUser);
try {
$customer = $customerProvider->getById($id);
if ($customer->getTypeOfUser() === 'superuser' && $loggedUser->getTypeOfUser() !== 'superuser') {
throw new AccessDeniedHttpException('You have no authorization.');
}
$payload = json_decode($request->getContent(), true);
$displayName = $payload['displayName'];
$customer->setDisplayName($displayName);
$permissions = $payload['permissions'];
$isManager = $payload['manager'];
$editHSAllowed = $permissions['headOffice']['editHS'];
$editTeamHQAllowed = $permissions['headOffice']['editTeamHQ'];
$placeOrderAllowed = $permissions['store']['placeOrder'];
$customer->setTypeOfUser($isManager ? 'manager' : 'subuser');
$customer->setEditHSAllowed($editHSAllowed ? true : false);
$customer->setEditTeamHQAllowed($editTeamHQAllowed ? true : false);
$customer->setPlaceOrderAllowed($placeOrderAllowed ? true : false);
$customer->save();
$response = new Response();
return $response->setContent(json_encode(['message' => 'OK']));
} catch (\Exception $e) {
throw new BadRequestHttpException($e->getMessage());
}
}
/**
* @Route("/practice/users", name="get-users-practice", methods={"GET"})
*/
public function getPracticeUsersAction(GeneralService $generalProvider)
{
$loggedUser = $this->getUser();
if (!$loggedUser) {
throw new UnauthorizedHttpException('Not authorized.');
}
$clinic = $loggedUser->getClinic();
$users = $generalProvider->getActiveUsersByClinic($clinic);
$data = [];
foreach ($users as $user) {
$userData = [
'id' => $user->getId(),
'firstName' => $user->getFirstname(),
'lastName' => $user->getLastname(),
'displayName' => $user->getDisplayName(),
'email' => $user->getEmail(),
'createdAt' => $user->getCreationDate(),
];
array_push($data, $userData);
}
$response = new Response();
$response->headers->set('Content-Type', 'application/json');
$response->headers->set('Access-Control-Allow-Origin', '*');
$response->setContent(json_encode(['users' => $data]));
return $response;
}
/**
* @Route("/report/error", name="report-error", methods={"POST"})
*/
public function reportErrorAction(Request $request)
{
$payload = json_decode($request->getContent(), true);
$error = $payload['error'];
\Pimcore\Log\Simple::log('front-end-report', $error);
$response = new Response();
return $response->setContent(json_encode(['message' => 'OK']));
}
/**
* @Route("/help/{uid}", name="get-help", methods={"GET"})
*/
public function getHelpAction($uid, Request $request)
{
$help = DataObject\Help::getByUid($uid, 1);
if (!$help) {
throw new InvalidArgumentException('Invalid UID');
}
$data = [
'title' => $help->getTitle(),
'content' => $help->getContent()
];
$response = new Response();
$response->headers->set('Content-Type', 'application/json');
$response->headers->set('Access-Control-Allow-Origin', '*');
$response->setContent(json_encode($data));
return $response;
}
}

src/Controller/ApiController.php line 2462