Symfony Profiler

<?php
namespace App\Controller;
use App\Async\AnswerNotificationMessage;
use App\Entity\Answer;
use App\Entity\AnswerContent;
use App\Entity\BigList;
use App\Entity\Comment;
use App\Entity\Device;
use App\Entity\Field;
use App\Entity\Form;
use App\Entity\Geolocation;
use App\Entity\Like;
use App\Entity\Log;
use App\Entity\MapObject;
use App\Entity\MapObjectType;
use App\Entity\Media;
use App\Entity\NotifParams;
use App\Entity\Shape;
use App\Entity\ShapeHasPoint;
use App\Entity\User;
use App\Entity\UserConnexion;
use App\Entity\UserEntity;
use App\Form\UserMobileType;
use App\Repository\AnimalRepository;
use App\Repository\AnswerContentRepository;
use App\Repository\AnswerRepository;
use App\Repository\BigListRepository;
use App\Repository\CategoryRepository;
use App\Repository\CityRepository;
use App\Repository\CommentRepository;
use App\Repository\DeviceRepository;
use App\Repository\EntityRepository;
use App\Repository\FieldRepository;
use App\Repository\FieldTypeRepository;
use App\Repository\FormRepository;
use App\Repository\GeolocationRepository;
use App\Repository\LikeRepository;
use App\Repository\LineRepository;
use App\Repository\LogRepository;
use App\Repository\MapObjectRepository;
use App\Repository\MapObjectTypeRepository;
use App\Repository\MediaRepository;
use App\Repository\NotifParamsRepository;
use App\Repository\SavedNotificationRepository;
use App\Repository\ProfileRepository;
use App\Repository\ShapeHasPointRepository;
use App\Repository\ShapeRepository;
use App\Repository\StatutAnswerRepository;
use App\Repository\TerritoryRepository;
use App\Repository\UserConnexionRepository;
use App\Repository\UserEntityRepository;
use App\Repository\UserRepository;
use App\Serialization\BigListSerialization;
use App\Serialization\CategorySerialization;
use App\Serialization\CommentSerialization;
use App\Serialization\FieldSerialization;
use App\Serialization\AnswerSerialization;
use App\Serialization\FormSerialization;
use App\Serialization\LineSerialization;
use App\Serialization\MapObjectTypeSerialization;
use App\Serialization\MediaSerialization;
use App\Serialization\NotifParamsSerialization;
use App\Serialization\SavedNotificationSerialization;
use App\Serialization\UserSerialization;
use App\Service\Fdc27Fence;
use App\Service\Fdc55Fence;
use App\Service\Fdc77Agrainage;
use App\Service\Fdc77Fence;
use App\Service\FileUploader;
use App\Service\Geocoder;
use App\Service\MailerService;
use App\Service\NotificationService;
use App\Service\UserRoleChecker;
use Doctrine\ORM\EntityManagerInterface;
use Dompdf\Dompdf;
use Elastica\Query;
use Elastica\Query\BoolQuery;
use Elastica\Query\Range;
use Exception;
use FOS\ElasticaBundle\Finder\TransformedFinder;
use FOS\ElasticaBundle\Persister\ObjectPersister;
use FOS\RestBundle\Controller\Annotations as Rest;
use Imagick;
use Kreait\Firebase\Exception\FirebaseException;
use Kreait\Firebase\Exception\MessagingException;
use Nzo\UrlEncryptorBundle\Encryptor\Encryptor;
use Psr\Container\ContainerExceptionInterface;
use Psr\Container\NotFoundExceptionInterface;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Mailer\Exception\TransportExceptionInterface;
use Symfony\Component\Messenger\MessageBusInterface;
use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
use Symfony\Component\Security\Core\Authentication\Token\UsernamePasswordToken;
use Symfony\Component\HttpFoundation\Session\Session;
use Symfony\Component\Security\Csrf\TokenGenerator\TokenGeneratorInterface;
/**
* ApiController.
*/
class ApiController extends AbstractController
{
/**
* @var false|string
*/
private $role;
public function __construct(UserRoleChecker $roleChecker,
private readonly Encryptor $encryptor,
public TransformedFinder $answersFinder, public TransformedFinder $map_objectsFinder,
public TransformedFinder $territoriesFinder,
public ObjectPersister $answersPersister, public ObjectPersister $map_objectsPersister)
{
$this->role = $roleChecker->getRole();
}
#[Rest\Get('/api-login')]
public function login(Request $request, UserRepository $userRepository,
UserPasswordHasherInterface $passwordEncoder,
UserConnexionRepository $userConnexionRepository, DeviceRepository $deviceRepository): JsonResponse
{
$params = ['email' => urldecode($request->query->get('email', ''))];
$user = $userRepository->findOneBy($params);
if (!$user)
return new JsonResponse(json_encode('forbidden'), 403, [], true);
//get password validation
$password = $passwordEncoder->isPasswordValid($user, $request->query->get('password', ''));
if ($user && $password) {
$token = new UsernamePasswordToken($user, "main", $user->getRoles());
$this->container->get('security.token_storage')->setToken($token);
$session = $this->container->get('request_stack')->getSession();
if (!$session->isStarted()) {
$session = new Session();
$session->start();
}
$identifier = $request->query->get('identifier', null);
$name = $request->query->get('name', '');
$userConnexion = new UserConnexion();
$userConnexion->setUser($this->getUser());
$userConnexion->setPlatform($name);
$userConnexionRepository->add($userConnexion, false);
//Check Device
if ($user->getDevice() == null && $identifier != null) {
//Add Device
$device = new Device();
$device->setName($name);
$device->setIdentifier($identifier);
$user->setDevice($device);
$deviceRepository->add($device, true);
} elseif ($identifier != null && $identifier != $user->getDevice()->getIdentifier()) {
//Update Device
$device = $user->getDevice();
$device->setName($name);
$device->setIdentifier($identifier);
$deviceRepository->add($device, true);
}
return new JsonResponse(
json_encode(['user' => UserSerialization::serializeUserForLogin($user, $session)], JSON_THROW_ON_ERROR), 200, [], true);
} else {
return new JsonResponse(json_encode('error'), 400, [], true);
}
}
#[Rest\Post('/api-register')]
public function register(Request $request, UserPasswordHasherInterface $userPasswordHasher, UserRepository $userRepository,
MailerService $mailerService): JsonResponse
{
$user = new User();
$params = $request->request->all();
//add Birthdate as object & remove it from parameters
$params['birthDate'] = explode("/", (string)$params['birthDate']);
$params["birthDate"] = $params["birthDate"][1] . "/" . $params["birthDate"][0] . "/" . $params["birthDate"][2];
$user->setBirthDate(new \DateTime($params['birthDate']));
unset($params['birthDate']);
$form = $this->createForm(UserMobileType::class, $user);
$params['isAccept'] = 0;
$params['isActivated'] = 1;
$form->submit($params, false);
if ($form->isSubmitted() && $form->isValid()) {
// Password
$user->setPassword(
$userPasswordHasher->hashPassword(
$user,
$form->getData()->getPassword()
)
);
$userRepository->add($user, true);
$userRepository->refresh($user);
foreach ($user->getUserEntities() as $entityUser) {
$mailerService->newUserApproval($entityUser->getAdmins(), $user, $entityUser);
}
//login registered User
$token = new UsernamePasswordToken($user, "main", $user->getRoles());
$this->container->get('security.token_storage')->setToken($token);
$session = $this->container->get('request_stack')->getSession();
if (!$session->isStarted()) {
$session = new Session();
$session->start();
}
return new JsonResponse(
json_encode(['user' => UserSerialization::serializeUserForLogin($user, $session)], JSON_THROW_ON_ERROR), 200, [], true);
} else {
$errors = [];
foreach ($form->getErrors(true) as $error) {
$errors[] = $error->getMessage();
}
return new JsonResponse(json_encode($errors, JSON_THROW_ON_ERROR), 400, [], true);
}
}
#[Rest\Post('/api-edit-user')]
public function editUser(Request $request, UserPasswordHasherInterface $userPasswordHasher,
UserRepository $userRepository, MapObjectRepository $mapObjectRepository): JsonResponse
{
$user = $this->getUser();
if (!$user) {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
}
$params = $request->request->all();
//add Birthdate as object & remove it from parameters
if (array_key_exists('birthDate', $params)) {
if ($params['birthDate'] !== "") {
$params['birthDate'] = explode("/", (string)$params['birthDate']);
$params["birthDate"] = $params["birthDate"][1] . "/" . $params["birthDate"][0] . "/" . $params["birthDate"][2];
$user->setBirthDate(new \DateTime($params['birthDate']));
unset($params['birthDate']);
}
}
$form = $this->createForm(UserMobileType::class, $user);
$form->submit($params, false);
if ($form->isSubmitted() && $form->isValid()) {
if ($request->request->get('password', '') != '') {
$user->setPassword(
$userPasswordHasher->hashPassword(
$user,
$form->getData()->getPassword()
)
);
}
$userRepository->add($user, true);
// Update Elasticsearch
if (!$user->getAnswers()->isEmpty()) {
$this->answersPersister->replaceMany($user->getAnswers()->getValues());
$mapObjects = $mapObjectRepository->findByUser($user);
if (!empty($mapObjects)) {
$this->map_objectsPersister->replaceMany($mapObjects);
}
}
return new JsonResponse(
json_encode(['user' => UserSerialization::serializeUserForLogin($user)], JSON_THROW_ON_ERROR), 200, [], true);
} else {
return new JsonResponse(json_encode('Bad Request'), 400, [], true);
}
}
#[Rest\Post('/api-edit-user-picture')]
public function updateProfilePicture(Request $request, UserRepository $userRepository, MapObjectRepository $mapObjectRepository): JsonResponse
{
$user = $this->getUser();
if (!$user) {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
}
$filesBag = $request->files->all()[0];
if (!is_null($filesBag)) {
$fileName = $filesBag->getClientOriginalName();
$fileName = md5(uniqid()) . '_' . $fileName;
$filesBag->move($this->getParameter('upload__publication_file_directory'), $fileName);
$user->setPicture($fileName);
}
$userRepository->add($user, true);
// Update Elasticsearch
if (!$user->getAnswers()->isEmpty()) {
$this->answersPersister->replaceMany($user->getAnswers()->getValues());
$mapObjects = $mapObjectRepository->findByUser($user);
if (!empty($mapObjects)) {
$this->map_objectsPersister->replaceMany($mapObjects);
}
}
return new JsonResponse(
json_encode(['picture' => $user->getPicture()], JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('/api-send-sms')]
public function sendSMS(UserRepository $userRepository): JsonResponse
{
if (!$this->getUser())
return new JsonResponse(json_encode('forbidden'), 403, [], true);
$user = $this->getUser();
$user->setSmsToken("000000");
$userRepository->add($user, true);
$sms = ['code' => $this->getUser()->getSmsToken()];
return new JsonResponse(json_encode("sended"), 200, [], true);
}
#[Rest\Post('/api-check-sms')]
public function checkSMS(Request $request, UserRepository $userRepository): JsonResponse
{
$checkCode = $request->request->get("code");
$user = $this->getUser();
if (!$user) {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
}
if ($checkCode == $user->getSmsToken()) {
$user->setIsActivated(true);
$userRepository->add($user, true);
return new JsonResponse(json_encode('granted'), 200, [], true);
} else {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
}
}
#[Rest\Post('/api-edit-user-entities')]
public function editUserEntities(Request $request, EntityRepository $entityRepository,
MailerService $mailerService, NotificationService $notificationService,
UserEntityRepository $userEntityRepository, UserRepository $userRepository,
MapObjectRepository $mapObjectRepository): JsonResponse
{
$user = $this->getUser();
if (!$user) {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
}
$entities = $request->request->all("entities");
$oldEntities = [];
$newEntities = [];
foreach ($user->getUserEntities() as $userEntity) {
if (!in_array($userEntity->getEntity()->getId(), $entities)) {
$user->removeUserEntity($userEntity);
}
$oldEntities[] = $userEntity->getEntity()->getId();
}
foreach ($entities as $entity) {
if (!in_array($entity, $oldEntities)) {
$newEntities[] = $entity;
}
}
foreach ($newEntities as $newEntity) {
$entity = $entityRepository->findOneById((int)$newEntity);
if ($entity) {
$userEntity = new UserEntity();
$userEntity->setEntity($entity);
$userEntity->setIsAccepted(false);
$userEntity->setUser($user);
$userEntityRepository->add($userEntity, false);
$mailerService->newUserApproval($entity->getAdmins(), $user, $entity);
}
}
$userRepository->add($user, true);
// Update Elasticsearch
if (!$user->getAnswers()->isEmpty()) {
$this->answersPersister->replaceMany($user->getAnswers()->getValues());
$mapObjects = $mapObjectRepository->findByUser($user);
if (!empty($mapObjects)) {
$this->map_objectsPersister->replaceMany($mapObjects);
}
}
return new JsonResponse(json_encode(['user' => UserSerialization::serializeUserForLogin($user)], JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Post('/api-post-user-entities')]
public function postUserEntities(Request $request, EntityRepository $entityRepository, MailerService $mailerService,
NotificationService $notificationService,
UserEntityRepository $userEntityRepository, MapObjectRepository $mapObjectRepository): JsonResponse
{
$user = $this->getUser();
if (!$user) {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
}
$entities = $request->request->all("entities");
$oldEntities = $userEntityRepository->findBy(['user' => $user]);
foreach ($oldEntities as $oldEntity) {
$userEntityRepository->remove($oldEntity, true);
}
foreach ($entities as $entity) {
$entity = $entityRepository->findOneById((int)$entity);
if ($entity) {
$userEntity = new UserEntity();
$userEntity->setEntity($entity);
$userEntity->setIsAccepted(false);
$userEntity->setUser($user);
$userEntityRepository->add($userEntity, true);
$mailerService->newUserApproval($entity->getAdmins(), $user, $entity);
};
}
// Update Elasticsearch
if (!$user->getAnswers()->isEmpty()) {
$this->answersPersister->replaceMany($user->getAnswers()->getValues());
$mapObjects = $mapObjectRepository->findByUser($user);
if (!empty($mapObjects)) {
$this->map_objectsPersister->replaceMany($mapObjects);
}
}
return new JsonResponse(json_encode(['user' => UserSerialization::serializeUserForLogin($user)], JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Post('/api-post-user-profiles')]
public function postUserProfiles(Request $request, ProfileRepository $profileRepository,
UserRepository $userRepository, MapObjectRepository $mapObjectRepository): JsonResponse
{
$user = $this->getUser();
if (!$user) {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
}
$profiles = $request->request->all("profiles");
$oldProfilesTemp = $user->getProfiles();
$oldProfiles = [];
// if profiles updates, delete old profiles
foreach ($oldProfilesTemp as $profile) {
$oldProfiles[] = $profile->getId();
$user->removeProfile($profile);
}
$addProfile = true;
if ($oldProfiles) {
$addProfile = false;
foreach ($profiles as $newProfile) {
if (!in_array($newProfile, $oldProfiles)) {
$addProfile = true;
}
}
}
if ($addProfile) {
foreach ($user->getUserEntities() as $userEntity) {
$userEntity->setIsAccepted(false);
}
}
foreach ($profiles as $profile) {
$profile = $profileRepository->findOneById((int)$profile);
if ($profile)
$user->addProfile($profile);
}
$userRepository->add($user, true);
// Update Elasticsearch
if (!$user->getAnswers()->isEmpty()) {
$this->answersPersister->replaceMany($user->getAnswers()->getValues());
$mapObjects = $mapObjectRepository->findByUser($user);
if (!empty($mapObjects)) {
$this->map_objectsPersister->replaceMany($mapObjects);
}
}
return new JsonResponse(json_encode(['user' => UserSerialization::serializeUserForLogin($user)], JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Post('/api-testfile')]
public function testFile(Request $request): JsonResponse
{
$filesResult = [];
$filesBag = $request->files->all();
foreach ($filesBag as $file) {
$filename = $file->getClientOriginalName();
$filesResult [] = $file->getPathname();
$file->move($this->getParameter('upload_file_directory'), $filename);
}
return new JsonResponse(json_encode($filesResult, JSON_THROW_ON_ERROR));
}
private function exportData($filename): array
{
$result = [];
if (($h = fopen("{$filename}", "r")) !== FALSE) {
while (($data = fgetcsv($h, 0, ",", '"')) !== FALSE) {
$result[] = $data;
}
fclose($h);
}
unset($result[0]);
return $result;
}
#[Rest\Post('/api-post-form')]
public function postFormAction(Request $request, ProfileRepository $profileRepository,
AnimalRepository $animalRepository, FieldTypeRepository $fieldTypeRepository,
EntityRepository $entityRepository, CategoryRepository $categoryRepository,
FieldRepository $fieldRepository, FormRepository $formRepository,
MapObjectTypeRepository $mapObjectTypeRepository, BigListRepository $bigListRepository): JsonResponse
{
$data = json_decode($request->getContent(), true, 512, JSON_THROW_ON_ERROR);
$form = new Form();
if ($this->role === "ROLE_ADMIN") {
$selectedEntity = $this->getUser()->getSelectedEntity()->getId();
$entity = $entityRepository->findOneBy(['id' => $selectedEntity]);
$form->setEntity($entity);
}
$form->setTitle($data['title']);
if ($data["publicationDate"]) {
$dateArray = explode('/', (string)$data['publicationDate']);
$date = $dateArray[0] . '-' . $dateArray[1] . '-' . $dateArray[2];
$form->setPublicationDate(new \DateTime($date));
}
if($data["publicationEnd"]) {
$dateArray = explode('/', (string)$data['publicationEnd']);
$dateEnd = $dateArray[0] . '-' . $dateArray[1] . '-' . $dateArray[2];
$form->setPublicationEnd(new \DateTime($dateEnd));
}
$form->setIsActive($data['isActive']);
if (array_key_exists("isShape", $data)) {
$form->setIsShape($data['isShape']);
}
if(array_key_exists("isLine", $data)){
$form->setIsPolyline($data['isLine']);
}
if (array_key_exists("isGeolocated", $data))
$form->setIsGeolocated($data['isGeolocated']);
if (array_key_exists("gotMedia", $data)) {
$form->setGotMedia($data['gotMedia']);
if (array_key_exists("mediaExplanation", $data)) {
$form->setMediaExplanation($data['mediaExplanation']);
}
}
$form->setIsPublic($data['isPublic']);
$form->setIsSigned($data['isSigned']);
$form->setDescription($data['description']);
$form->setIsBooking($data['isBooking']);
$form->setBookingSpace($data['bookingSpace']);
if (array_key_exists("bookingNumber", $data)) {
$form->setNumberBooking($data['bookingNumber']);
}
if (array_key_exists("bookingDate", $data)) {
if ($data['bookingDate']) {
$dateArray = explode('/', (string)$data['bookingDate']);
$date = $dateArray[0] . '-' . $dateArray[1] . '-' . $dateArray[2];
$form->setBookingDate(new \DateTime($date));
}
}
foreach ($data['profiles'] as $profile) {
$profile = $profileRepository->findOneById($profile);
$form->addProfile($profile);
}
$category = $categoryRepository->findOneById($data['category']);
$form->setCategory($category);
$form->setIsAnimal($data['isAnimal']);
if ($data['animal'])
$form->setAnimal($animalRepository->findOneById($data['animal']));
//Add fiel for booking
if ($data["isBooking"] === true) {
if ($data['bookingNameDisplay']) {
$form->setBookingNameDisplay(true);
}
$fieldType = $fieldTypeRepository->findOneBy(['name' => 'select']);
$fieldBooking = new Field();
$fieldBooking->setFieldType($fieldType);
$fieldBooking->setTitle("Nombre de places");
$fieldBooking->setIsRequired(true);
$fieldBooking->setIsBooking(true);
$fieldRepository->add($fieldBooking, false);
$form->addField($fieldBooking);
$fieldType = $fieldTypeRepository->findOneBy(['name' => 'userBooking']);
$fieldUserBooking = new Field();
$fieldUserBooking->setFieldType($fieldType);
$fieldUserBooking->setTitle("Users");
$fieldUserBooking->setIsRequired(true);
$fieldUserBooking->setIsBooking(false);
$fieldRepository->add($fieldUserBooking, false);
$form->addField($fieldUserBooking);
}
if (array_key_exists('isObject', $data)) {
$form->setIsLinkedToObject($data['isObject']);
if ($form->getIsLinkedToObject()) {
$form->setMapObjectType($mapObjectTypeRepository->findOneBy(['id' => $data['objectTypeSelected']]));
}
}
//Add fields
foreach ($data['arrayField'] as $receivedField) {
$field = new Field();
$field->setTitle($receivedField['fieldTitle']);
$field->setIsRequired($receivedField['fieldRequired']);
$field->setFieldType($fieldTypeRepository->findOneByName($receivedField['fieldType']));
if ($receivedField['fieldAnimal']) {
$field->setAnimal($animalRepository->findOneById($receivedField['fieldAnimal']));
}
if ($field->getFieldType()->getName() == 'bigList' || $field->getFieldType()->getName() == 'bigListMultiple') {
$field->setBigList($bigListRepository->findOneBy(['id' => $receivedField['fieldBigList']]));
}
if ($field->getFieldType()->getName() == "animals" || $field->getFieldType()->getName() == "animal") {
if ($receivedField['fieldAnimals'])
if (!empty($receivedField['fieldAnimals'])) {
$options = [];
foreach ($receivedField['fieldAnimals'] as $animal) {
$options[] = $animal;
}
$field->setOptions($options);
}
} else {
if ($receivedField['fieldOptions'])
if (!empty($receivedField['fieldOptions'])) {
$options = [];
if ($receivedField['fieldOptions'][0]['option'] != "")
foreach ($receivedField['fieldOptions'] as $option) {
$options[] = $option['option'];
}
$field->setOptions($options);
}
}
if ($field->getFieldType()->getName() == 'surface') {
$field->setUnit($receivedField['fieldUnit']);
}
$field->setForm($form);
$fieldRepository->add($field, false);
$form->addField($field);
}
$formRepository->add($form, true);
return new JsonResponse(json_encode($form->getId(), JSON_THROW_ON_ERROR));
}
#[Rest\Post('/api-post-media-description-form')]
public function postDescriptionMediaAction(Request $request, FormRepository $formRepository,
MediaRepository $mediaRepository, FileUploader $fileUploader): JsonResponse
{
$form = $formRepository->findOneBy(['id' => $request->request->get('form', null)]);
//PDF
$pdf = $request->files->get("pdf");
//TODO: USE FILEUPLOADER
if ($pdf) {
$path = $this->getParameter('upload__form_pdf_directory');
$filename = $fileUploader->upload($pdf, $path);
$media = new Media();
$media->setFilename($filename);
$media->setMimeType($pdf->getClientMimeType());
$media->setPath($path . "/" . $filename);
$media->setFormPdf($form);
$mediaRepository->add($media, false);
$request->files->remove('pdf');
}
//Old pdf in case of duplication
$oldPdf = $request->request->get("oldPdf", null);
if ($oldPdf) {
$oldPdf = $mediaRepository->findOneBy(['id' => $oldPdf]);
$newPdf = new Media();
$filename = $oldPdf->getFilename();
$filename = md5(uniqid()) . '_' . $filename;
$newPdf->setFilename($filename);
$newPdf->setMimeType($oldPdf->getMimeType());
copy($this->getParameter('upload__form_pdf_directory') . "/" . $oldPdf->getFilename(), $this->getParameter('upload__form_pdf_directory') . "/" . $filename);
$newPdf->setPath($this->getParameter('upload__form_pdf_directory') . "/" . $filename);
$newPdf->setFormPdf($form);
$mediaRepository->add($newPdf, false);
}
//Pictures
$filesBag = $request->files->all();
foreach ($filesBag as $file) {
$path = $this->getParameter('upload__form_pictures_directory');
$filename = $fileUploader->upload($file, $path);
$media = new Media();
$media->setFilename($filename);
$media->setMimeType($file->getClientMimeType());
$media->setPath($path . "/" . $filename);
$mediaRepository->add($media, false);
$form->addPicture($media);
}
//Old pictures in case of duplication
foreach ($request->request->all("oldPictures") as $oldPicture) {
$oldPicture = $mediaRepository->findOneBy(['id' => $oldPicture]);
$newPicture = new Media();
$filename = $oldPicture->getFilename();
$filename = md5(uniqid()) . '_' . $filename;
$newPicture->setFilename($filename);
$newPicture->setMimeType($oldPicture->getMimeType());
copy($this->getParameter('upload__form_pictures_directory') . "/" . $oldPicture->getFilename(), $this->getParameter('upload__form_pictures_directory') . "/" . $filename);
$newPicture->setPath($this->getParameter('upload__form_pictures_directory') . "/" . $filename);
$mediaRepository->add($newPicture, false);
$form->addPicture($newPicture);
}
$formRepository->add($form, true);
return new JsonResponse(json_encode(true, JSON_THROW_ON_ERROR));
}
#[Rest\Post('/api-delete-post-media-description-form')]
public function postDeleteDescriptionMediaAction(Request $request, FormRepository $formRepository, MediaRepository $mediaRepository): JsonResponse
{
$data = json_decode($request->getContent(), true, 512, JSON_THROW_ON_ERROR);
$form = $formRepository->findOneBy(['id' => $data['form']]);
//PDF
if (array_key_exists("pdf", $data)) {
if ($data['pdf']) {
$pdf = $form->getPdf();
unlink($this->getParameter('upload__form_pdf_directory') . "/" . $pdf->getFilename());
$mediaRepository->remove($pdf, true);
}
}
if (array_key_exists("pictures", $data)) {
$pictures = $data["pictures"];
foreach ($pictures as $picture) {
$picture = $mediaRepository->findOneBy(['id' => $picture]);
unlink($this->getParameter('upload__form_pictures_directory') . "/" . $picture->getFilename());
$mediaRepository->remove($picture, true);
}
}
$formRepository->add($form, true);
return new JsonResponse(json_encode(true, JSON_THROW_ON_ERROR));
}
#[Rest\Post('/api-edit-form')]
public function postEditFormAction(Request $request, ProfileRepository $profileRepository,
AnimalRepository $animalRepository, FieldTypeRepository $fieldTypeRepository,
FormRepository $formRepository, FieldRepository $fieldRepository,
CategoryRepository $categoryRepository, MapObjectTypeRepository $mapObjectTypeRepository,
BigListRepository $bigListRepository): JsonResponse
{
$data = json_decode($request->getContent(), true, 512, JSON_THROW_ON_ERROR);
$form = $formRepository->findOneById($data['form']);
if ($form) {
$form->setTitle($data['title']);
if ($data["publicationDate"]) {
$dateArray = explode('/', (string)$data['publicationDate']);
$date = $dateArray[0] . '-' . $dateArray[1] . '-' . $dateArray[2];
$form->setPublicationDate(new \DateTime($date));
}
if ($data["publicationEnd"]){
$dateArray = explode('/', (string)$data['publicationEnd']);
$dateEnd = $dateArray[0] . '-' . $dateArray[1] . '-' . $dateArray[2];
$form->setPublicationEnd(new \DateTime($dateEnd));
}else{
$form->setPublicationEnd(null);
}
$form->setIsActive($data['isActive']);
$form->setDescription($data['description']);
$form->removeAllProfiles();
foreach ($data['profiles'] as $profile) {
$profile = $profileRepository->findOneById($profile);
$form->addProfile($profile);
}
$category = $categoryRepository->findOneById($data['category']);
$form->setCategory($category);
$form->setIsAnimal($data['isAnimal']);
if ($data['animal']) {
$form->setAnimal($animalRepository->findOneById($data['animal']));
}
$form->setBookingNameDisplay($data['bookingNameDisplay']);
$form->setIsShape($data['isShape']);
if (array_key_exists("gotMedia", $data)) {
$form->setGotMedia($data['gotMedia']);
if (array_key_exists("mediaExplanation", $data)) {
$form->setMediaExplanation($data['mediaExplanation']);
}
}
$form->setIsGeolocated($data['isGeolocated']);
$form->setIsPublic($data['isPublic']);
$form->setIsSigned($data['isSigned']);
$form->setIsBooking($data['isBooking']);
$form->setBookingSpace($data['bookingSpace']);
if (array_key_exists("bookingNumber", $data)) {
$form->setNumberBooking($data['bookingNumber']);
}
if (array_key_exists("bookingDate", $data)) {
if ($data['bookingDate']) {
$dateArray = explode('/', (string)$data['bookingDate']);
$date = $dateArray[0] . '-' . $dateArray[1] . '-' . $dateArray[2];
$form->setBookingDate(new \DateTime($date));
}
}
foreach ($data['arrayField'] as $receivedField) {
if (array_key_exists('id', $receivedField)) {
$field = $fieldRepository->findOneById($receivedField['id']);
} else {
$field = new Field();
}
$field->setOptions([]);
$field->setTitle($receivedField['fieldTitle']);
$field->setIsRequired($receivedField['fieldRequired']);
$field->setFieldType($fieldTypeRepository->findOneByName($receivedField['fieldType']));
if ($field->getFieldType()->getName() == 'bigList' || $field->getFieldType()->getName() == 'bigListMultiple') {
$field->setBigList($bigListRepository->findOneBy(['id' => $receivedField['fieldBigList']]));
}
if ($receivedField['fieldAnimal']) {
$field->setAnimal($animalRepository->findOneById($receivedField['fieldAnimal']));
}
if ($field->getFieldType()->getName() == "animals" || $field->getFieldType()->getName() == "animal") {
if ($receivedField['fieldAnimals'])
if (!empty($receivedField['fieldAnimals'])) {
$options = [];
foreach ($receivedField['fieldAnimals'] as $animal) {
$options[] = $animal;
}
$field->setOptions($options);
}
} else {
if ($receivedField['fieldOptions'])
if (!empty($receivedField['fieldOptions'])) {
$options = [];
if ($receivedField['fieldOptions'][0]['option'] != "")
foreach ($receivedField['fieldOptions'] as $option) {
$options[] = $option['option'];
}
$field->setOptions($options);
}
}
if ($field->getFieldType()->getName() == 'surface') {
$field->setUnit($receivedField['fieldUnit']);
}
$fieldRepository->add($field, false);
if (!array_key_exists('id', $receivedField)) {
$form->addField($field);
}
}
if (array_key_exists('isObject', $data)) {
$form->setIsLinkedToObject($data['isObject']);
if ($form->getIsLinkedToObject()) {
$form->setMapObjectType($mapObjectTypeRepository->findOneBy(['id' => $data['objectTypeSelected']]));
}
}
}
$formRepository->add($form, true);
// Update Elasticsearch
if (!$form->getAnswers()->isEmpty()) {
$this->answersPersister->replaceMany($form->getAnswers()->getValues());
if ($form->getMapObjectType())
if (!empty($form->getMapObjectType()->getMapObjects()->getValues()))
$this->map_objectsPersister->replaceMany($form->getMapObjectType()->getMapObjects()->getValues());
}
return new JsonResponse(json_encode($form->getId(), JSON_THROW_ON_ERROR));
}
#[Rest\Get('/api-get-form')]
public function getFormAction(Request $request, FormRepository $formRepository, AnimalRepository $animalRepository): JsonResponse
{
$form = $formRepository->findOneById($request->query->get('form'));
$profiles = [];
foreach ($form->getProfiles() as $profile) {
$profiles [] = $profile->getId();
}
$return = [
'title' => $form->getTitle(),
'isActive' => $form->getIsActive(),
'description' => $form->getDescription(),
'isAnimal' => $form->getIsAnimal(),
'isGeolocated' => $form->getIsGeolocated(),
'isShape' => $form->getIsShape(),
'isPolyline' => $form->getIsPolyline(),
'mediaDescription' => $form->getMediaExplanation(),
'gotMedia' => $form->getGotMedia(),
'isPublic' => $form->getIsPublic(),
'isSigned' => $form->getIsSigned(),
'animal' => $form->getAnimal() ? $form->getAnimal()->getId() : "",
'publicationDate' => $form->getPublicationDate()->format("d/m/Y"),
'publicationEnd' => $form->getPublicationEnd() ? $form->getPublicationEnd()->format("d/m/Y") : null,
'profiles' => $profiles,
'category' => $form->getCategory() ? $form->getCategory()->getId() : null,
'arrayField' => FieldSerialization::serializeWebFields($form->getFields(), $animalRepository),
'isBooking' => $form->getIsBooking(),
'bookingNumber' => $form->getNumberBooking(),
'bookingDate' => $form->getBookingDate() ? $form->getBookingDate()->format("d/m/Y") : "",
'pdf' => $form->getPdf() ? MediaSerialization::serializeMedia($form->getPdf()) : null,
'pictures' => !$form->getPictures()->isEmpty() ? MediaSerialization::serializeMedias($form->getPictures()) : [],
'bookingNameDisplay' => $form->getBookingNameDisplay(),
'anyAnswers' => is_countable($form->getAnswers()) ? count($form->getAnswers()) : 0,
'bookingSpace' => $form->getBookingSpace(),
'isLinkedToObject' => $form->getIsLinkedToObject(),
'objectTypeSelected' => $form->getMapObjectType()?->getId()
];
return new JsonResponse($return);
}
#[Rest\Get('/api-get-forms')]
public function getFormsAction(FormRepository $formRepository): JsonResponse
{
if (!$this->getUser())
return new JsonResponse(json_encode('forbidden'), 403, [], true);
//$forms = $formRepository->findAll();
$forms = $formRepository->findAllByUser($this->getUser(), true);
$forms = FormSerialization::serializeForms($forms);
return new JsonResponse(json_encode($forms, JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('/api-get-forms-categories')]
public function getFormsCategoriesAction(FormRepository $formRepository): JsonResponse
{
if (!$this->getUser())
return new JsonResponse(json_encode('forbidden'), 403, [], true);
//$forms = $formRepository->findAll();
$forms = $formRepository->findAllByUser($this->getUser(), true);
// TODO: SuperAdmin
$undefined = [];
$categories = [];
foreach ($forms as $form) {
if ($form->getCategory() == null) {
$undefined[] = $form;
} else {
$category = $form->getCategory();
if (!array_key_exists($category->getId(), $categories)) {
$categories[$category->getId()] = [];
$categories[$category->getId()]["category"] = $category;
$categories[$category->getId()]["forms"] = [];
}
$categories[$category->getId()]["forms"][] = $form;
}
}
$results = [];
foreach ($categories as $categoryTab) {
$results[] = CategorySerialization::serializeFeedCategory($categoryTab["category"], $categoryTab["forms"]);
}
usort($results, function ($a, $b) {
return $a['name'] <=> $b['name'];
});
$results[] = [
"id" => 0,
"name" => "Undefined",
"forms" => FormSerialization::serializeForms($undefined)
];
return new JsonResponse(json_encode($results, JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('/api-get-feed')]
public function getAnswerFeedAction(Request $request, LineRepository $lineRepository, AnimalRepository $animalRepository,): JsonResponse
{
if (!$this->getUser())
return new JsonResponse(json_encode('forbidden'), 403, [], true);
$limit = $request->query->get('limit', 50);
$offset = $request->query->get('offset', 0);
$isNew = $request->query->get('isNew', false);
$answers = $this->answersElastica(true, $limit, $offset);
$answers = AnswerSerialization::serializeFeedAnswers($answers, $animalRepository, $this->getUser(), $lineRepository);
$validated = false;
foreach ($this->getUser()->getUserEntities() as $userEntity) {
if ($userEntity->getIsAccepted()) {
$validated = true;
}
}
if (!$isNew) {
return new JsonResponse(json_encode($answers, JSON_THROW_ON_ERROR), 200, [], true);
} else {
return new JsonResponse(json_encode(['answers' => $answers, 'validated' => $validated], JSON_THROW_ON_ERROR), 200, [], true);
}
}
#[Rest\Get('/api-get-feed-for-days')]
public function getAnswerFromDays(Request $request, AnswerRepository $answerRepository, AnimalRepository $animalRepository,
LineRepository $lineRepository): JsonResponse
{
if (!$this->getUser())
return new JsonResponse(json_encode('forbidden'), 403, [], true);
$daysFrom = $request->query->get("days");
$answers = $answerRepository->findAllDaysAgoByUser($this->getUser(), null, null, null, null, $daysFrom ?? 7);
$answers = AnswerSerialization::serializeFeedAnswers($answers, $animalRepository, $this->getUser(), $lineRepository);
return new JsonResponse(json_encode($answers, JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('/api-count-feed-for-days')]
public function countAnswerFromDays(Request $request, AnswerRepository $answerRepository, AnimalRepository $animalRepository,
Geocoder $geocoder, MediaRepository $mediaRepository): JsonResponse
{
if (!$this->getUser())
return new JsonResponse(json_encode('forbidden'), 403, [], true);
$daysFrom = $request->query->get("days");
$answers = $answerRepository->countAllAnswersForDaysByUser($this->getUser(), null, null, null, null, $daysFrom ?? 7);
return new JsonResponse(json_encode(['feedCounter' => $answers], JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('/api-get-personal-feed')]
public function getAnswerPersonalFeedAction(Request $request, AnswerRepository $answerRepository,
AnimalRepository $animalRepository, LineRepository $lineRepository): JsonResponse
{
if (!$this->getUser())
return new JsonResponse(json_encode('forbidden'), 403, [], true);
$limit = $request->query->get('limit', 10);
$offset = $request->query->get('offset', 0);
$answers = $answerRepository->findPersonal($this->getUser(), $limit, $offset);
$answers = AnswerSerialization::serializeFeedAnswers($answers, $animalRepository, $this->getUser(), $lineRepository);
return new JsonResponse(json_encode($answers, JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('/api-get-delete-user')]
public function getDeleteUserAction(UserRepository $userRepository, MapObjectRepository $mapObjectRepository): JsonResponse
{
if (!$this->getUser())
return new JsonResponse(json_encode('forbidden'), 403, [], true);
$user = $this->getUser();
foreach ($user->getAnswers() as $answer) {
$answer->setAuthor($userRepository->findOneByEmail("anonyme@anonyme.fr"));
// Update Elasticsearch
}
if (!$user->getAnswers()->isEmpty()) {
$this->answersPersister->replaceMany($user->getAnswers()->getValues());
}
$mapObjects = $mapObjectRepository->findByUser($user);
if (!empty($mapObjects)) {
$this->map_objectsPersister->replaceMany($mapObjects);
}
$userRepository->remove($user, true);
return new JsonResponse(json_encode(true, JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('/api-get-detail')]
public function getAnswerDetailAction(Request $request, AnswerRepository $answerRepository, AnimalRepository $animalRepository, LineRepository $lineRepository): JsonResponse
{
if (!$this->getUser())
return new JsonResponse(json_encode('forbidden'), 403, [], true);
$answer = $answerRepository->findOneById($request->query->get("id"));
$answer = AnswerSerialization::serializeDetailAnswer($answer, $animalRepository, $this->getUser(), $lineRepository);
return new JsonResponse(json_encode($answer, JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('/api-get-form-fields')]
public function getFormFieldsAction(Request $request, FormRepository $formRepository, AnimalRepository $animalRepository): JsonResponse
{
if (!$this->getUser())
return new JsonResponse(json_encode('forbidden'), 403, [], true);
$form = $formRepository->findOneById($request->query->get("id"));
if (!$form) {
return new JsonResponse(json_encode('Bad request'), 400, [], true);
} else {
$fields = FieldSerialization::serializeFields($form->getFields(), $animalRepository);
return new JsonResponse(json_encode($fields, JSON_THROW_ON_ERROR), 200, [], true);
}
}
#[Rest\Get('/api-get-answer-count-by-date')]
public function getAnswerCountByDateAction(Request $request, AnswerRepository $answerRepository): JsonResponse
{
$result = [];
if (!$this->getUser())
return new JsonResponse(json_encode('forbidden'), 403, [], true);
$dateStart = new \DateTimeImmutable($request->query->get('startDate'));
$dateEnd = new \DateTimeImmutable($request->query->get('endDate'));
$result["answersCounts"] = $answerRepository->countAllAsAdminByIntervalDate($this->getUser(), $dateStart, $dateEnd);
$result["count"] = $result["answersCounts"]["count"];
unset($result["answersCounts"]["count"]);
return new JsonResponse(json_encode($result, JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('/api-get-inscription-count-by-date')]
public function getInscriptionCountByDateAction(Request $request, UserRepository $userRepository): JsonResponse
{
$result = [];
if (!$this->getUser())
return new JsonResponse(json_encode('forbidden'), 403, [], true);
$dateStart = new \DateTimeImmutable($request->query->get('startDate'));
$dateEnd = new \DateTimeImmutable($request->query->get('endDate'));
$result["inscriptionsCounts"] = $userRepository->countAllAsAdminByIntervalDate($this->getUser(), $dateStart, $dateEnd);
$result["count"] = $result["inscriptionsCounts"]["count"];
unset($result["inscriptionsCounts"]["count"]);
return new JsonResponse(json_encode($result, JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('/api-get-profil-by-inscription')]
public function getProfilByInscription(Request $request, ProfileRepository $profileRepository): JsonResponse
{
if (!$this->getUser())
return new JsonResponse(json_encode('forbidden'), 403, [], true);
$dateStart = new \Datetime($request->query->get('startDate'));
$dateEnd = new \Datetime($request->query->get('endDate'));
$answersCounts = $profileRepository->getProfileOfCountAllAsAdminByIntervalleDate($this->getUser(), $dateStart, $dateEnd);
return new JsonResponse(json_encode($answersCounts, JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('/api-get-title-by-form-answer')]
public function getTitleByFormAnswer(request $request, AnswerRepository $answerRepository): JsonResponse
{
if (!$this->getUser())
return new JsonResponse(json_encode('forbidden'), 403, [], true);
$dateStart = new \DateTime($request->query->get('startDate'));
$dateEnd = new \DateTime($request->query->get('endDate'));
$answersCounts = $answerRepository->countTitleAllAsAdminByIntervalDate($this->getUser(), $dateStart, $dateEnd);
return new JsonResponse(json_encode($answersCounts, JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Post('/api-post-answer')]
public function postAnswerAction(
Request $request, FormRepository $formRepository, FieldRepository $fieldRepository,
GeolocationRepository $geolocationRepository, CityRepository $cityRepository,
Geocoder $geocoder, AnswerContentRepository $answerContentRepository,
MailerService $email, FileUploader $fileUploader, MessageBusInterface $messageBus,
NotificationService $notificationService, AnswerRepository $answerRepository,
ShapeHasPointRepository $shapeHasPointRepository, ShapeRepository $shapeRepository, MediaRepository $mediaRepository,
MapObjectRepository $mapObjectRepository, MapObjectTypeRepository $mapObjectTypeRepository,
Fdc55Fence $fdc55Fence, Fdc77Fence $fdc77Fence, Fdc27Fence $fdc27Fence, Fdc77Agrainage $fdc77Agrainage): JsonResponse
{
$placeAvailableEmail = null;
$mapObjectLinked = null;
$user = $this->getUser();
if (!$user) {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
}
$form = $formRepository->findOneById($request->request->get('form', ''));
if (!$form) {
return new JsonResponse(json_encode('Bad request For Form'), 400, [], true);
}
$answer = new Answer();
$answer->setAuthor($user);
$answer->setForm($form);
if ($form->getIsLinkedToObject()) {
$mapObjectLinked = $mapObjectRepository->findOneBy(['id' => $request->request->get('objectId', '')]);
$answer->setMapObject($mapObjectLinked);
}
if ($request->request->get('private') == "true") {
$answer->setPrivate(true);
} else {
$answer->setPrivate(false);
}
$latitude = (float)$request->request->get('latitude', null);
$longitude = (float)$request->request->get('longitude', null);
if ($answer->getForm()->getIsGeolocated() === true && !$form->getIsLinkedToObject()) {
if (!$latitude && !$longitude) {
return new JsonResponse(json_encode('Bad request For Geolocation'), 400, [], true);
}
$geolocation = new Geolocation();
$geolocation->setLat($latitude);
$geolocation->setLng($longitude);
$city = $geocoder->reverseGeocode($latitude, $longitude);
$geolocation->setFullAddress($city["fullAdress"]);
if (array_key_exists("ville", $city)) {
$city = $city['ville'];
$city = $cityRepository->findOneByCityName($city);
if ((is_countable($city) ? count($city) : 0) > 0) {
$geolocation->setCity($city[0]);
}
}
$geolocationRepository->add($geolocation, false);
$answer->setGeolocation($geolocation);
}
if (($answer->getForm()->getIsShape() === true || $answer->getForm()->getIsPolyline() === true) && !$form->getIsLinkedToObject()) {
$shape = new Shape();
$points = $request->request->all('shape');
$type = $request->request->get('shapeType', $answer->getForm()->getIsPolyline() === true ? "polyline" : "polygon");
$shape->setType($type);
if (!empty($points)) {
$geolocation = new Geolocation();
$geolocation->setLat($points[0]['lat']);
$geolocation->setLng($points[0]['lng']);
$city = $geocoder->reverseGeocode($geolocation->getLat(), $geolocation->getLng());
$geolocation->setFullAddress($city["fullAdress"]);
if (array_key_exists("ville", $city)) {
$city = $city['ville'];
$city = $cityRepository->findOneByCityName($city);
if ((is_countable($city) ? count($city) : 0) > 0) {
$geolocation->setCity($city[0]);
}
}
$geolocationRepository->add($geolocation, false);
$answer->setGeolocation($geolocation);
foreach ($points as $point) {
$shapeAsPoint = new ShapeHasPoint();
$shapeAsPoint->setShape($shape);
$shapeAsPoint->setLat($point['lat']);
$shapeAsPoint->setLng($point['lng']);
$shapeHasPointRepository->add($shapeAsPoint, false);
$shape->addShapeHasPoint($shapeAsPoint);
}
} else
return new JsonResponse(json_encode('Bad request For Shape'), 400, [], true);
$shapeRepository->add($shape, false);
$answer->setShape($shape);
}
$timestamp = $request->request->get('publicationDate', null);
if ($timestamp != null) {
$pubDate = new \DateTime();
$pubDate->setTimestamp($timestamp);
// $pubDate->format("d/m/Y à H:i");
$answer->setDate($pubDate);
} else {
$pubDate = new \DateTime('now');
$answer->setDate($pubDate);
}
$answers = $request->request->all('answers');
$placeBooking = '';
$placesAvailableEmail = '';
for ($i = 0; $i < count($answers); $i++) {
$content = $answers[$i];
//Booking places available
if (array_key_exists('isBooking', $content)) {
if ($content['isBooking'] == 'true') {
$answerBooking = $answerContentRepository->findBy(['field' => $content['field']]);
$places = $formRepository->findOneBy(['id' => $form]);
$placeAvailable = '';
if ($answerBooking) {
// Subtract number of available places
$integer = 0;
foreach ($answerBooking as $value) {
$integer = $integer + $value->getContent();
}
$placesAvailable = $places->getNumberBooking() - $integer;
} else {
// Display number places origin
$placesAvailable = $places->getNumberBooking();
}
if ($answer->getForm()->getBookingSpace()) {
$placeBooking = 1;
} else {
$placeBooking = $content['content'];
}
if ($placesAvailable - $placeBooking < 0) {
return new JsonResponse(json_encode(false, JSON_THROW_ON_ERROR), 200, [], true);
} else {
$placeAvailableEmail = $placesAvailable - $placeBooking;
}
}
}
$answerContent = new AnswerContent();
if (array_key_exists('isBooking', $content)) {
if ($content['isBooking'] == 'true') {
$answerContent->setContent(1);
} else {
$answerContent->setContent($content['content']);
}
} else {
$answerContent->setContent($content['content']);
}
$answerContent->setField($fieldRepository->findOneById($content['field']));
if ($answerContent->getField()->getForm() == $answer->getForm()) {
$answerContentRepository->add($answerContent, false);
$answer->addAnswerContent($answerContent);
}
}
$filesBag = $request->files->all();
// Files
$path = $this->getParameter('upload__publication_file_directory');
foreach ($filesBag as $key => $file) {
if ($key != 'signature') {
$filename = $fileUploader->upload($file, $path);
$mimeType = $file->getClientMimeType();
if (str_contains((string)$mimeType, "heic") || str_contains((string)$mimeType, "heif")) {
// convert heic or heif to jpg
$im = new Imagick($path . "/" . $filename);
$im->setCompression(Imagick::COMPRESSION_JPEG);
$im->setCompressionQuality(90);
$im->setImageFormat('jpeg');
$oldName = $filename;
if (str_contains((string)$mimeType, "heic")) {
//rename file for new extension
$filename = str_replace('.heic', '.jpg', $filename);
//reset mimeType for media
$mimeType = str_replace('heic', 'jpg', (string)$mimeType);
} else if (str_contains((string)$mimeType, "heif")) {
//rename file for new extension
$filename = str_replace('.heif', '.jpg', $filename);
//reset mimeType for media
$mimeType = str_replace('heif', 'jpg', (string)$mimeType);
}
unlink($path . "/" . $oldName);
if ($im->getImageWidth() < $im->getImageHeight()) {
$rotate = "portrait";
} else {
$rotate = "landscape";
}
switch ($rotate) {
case "portrait":
$im->scaleImage(720, 1280, true);
break;
case "landscape":
$im->scaleImage(1280, 720, true);
break;
default:
break;
}
$im->writeImage($path . "/" . $filename);
$im->clear();
}
$media = new Media();
$media->setFilename($filename);
$media->setMimeType($mimeType);
$media->setPath($path . "/" . $filename);
$mediaRepository->add($media, false);
$answer->addMedia($media);
}
}
if ($answer->getForm()->getIsSigned() === true) {
$signature = $request->files->get('signature');
if ($signature) {
$filename = $fileUploader->upload($signature, $path);
$media = new Media();
$media->setFilename($filename);
$media->setMimeType($signature->getClientMimeType());
$media->setPath($path . "/" . $filename);
$mediaRepository->add($media, false);
$answer->setSignature($media);
} else {
return new JsonResponse(json_encode("Aucune signature trouvée"), 400, [], true);
}
}
$isDouble = $answerRepository->isDouble($user, $pubDate, $latitude, $longitude);
if (empty($isDouble)) {
$answerRepository->add($answer, true);
// Encode video async
if (!$answer->getMedias()->isEmpty()) {
$messageBus->dispatch(new AnswerNotificationMessage($answer->getId()));
}
if ($form->getIsBooking()) {
$email->sendBookingAdmins($user, $placeBooking, $form, $placeAvailableEmail);
$email->sendBookingUser($user, $form);
}
$admins = $form->getEntity()->getAdmins();
$adminSend = [];
$adminSave = [];
foreach ($admins as $admin) {
if ($admin != $user)
if ($admin->getNotifParams()->getNewPublication()) {
$adminSend[] = $admin;
} else {
$adminSave[] = $admin;
}
}
$title = "Une nouvelle publication a été ajoutée à votre entité";
$body = $user->getLastName() . " " . $user->getName() . " à publié dans le formulaire " . $form->getTitle();
$data = ["type" => "answerAdmin",
"id" => $answer->getId()];
$notificationService->saveNotifications($adminSave, $title, $body, $data);
$notificationService->sendNotifications($adminSend, $title, $body, $data);
if ($form->getIsObject()) {
$mapObject = new MapObject();
$geolocation = new Geolocation();
$geolocation->setLat($answer->getGeolocation()->getLat());
$geolocation->setLng($answer->getGeolocation()->getLng());
$geolocation->setCity($answer->getGeolocation()->getCity());
$geolocationRepository->add($geolocation, false);
$mapObject->setGeolocation($geolocation);
$mapObject->setAnswer($answer);
if ($mapObject->getShape()) {
$mapObjectShape = new Shape();
$mapObjectShape->setType($answer->getShape()->getType());
foreach ($answer->getShape()->getShapeHasPoints() as $shapeHasPoint) {
$newShapeHasPoint = new ShapeHasPoint();
$newShapeHasPoint->setLat($shapeHasPoint->getLat());
$newShapeHasPoint->setLng($shapeHasPoint->getLng());
$newShapeHasPoint->setShape($mapObjectShape);
$shapeHasPointRepository->add($newShapeHasPoint, false);
$mapObjectShape->addShapeHasPoint($newShapeHasPoint);
}
$shapeRepository->add($mapObjectShape, false);
$mapObject->setShape($mapObjectShape);
}
$mapObjectType = $mapObjectTypeRepository->findOneBy(['form' => $form]);
if ($mapObjectType) {
if ($mapObjectType->getLegendField()) {
$answerContent = $answerContentRepository->findOneBy(['answer' => $answer, 'field' => $mapObjectType->getLegendField()]);
if ($answerContent?->getContent()) {
$mapObject->setLegend($answerContent->getContent());
} else {
$mapObject->setLegend($answer->getId());
}
} elseif ($mapObjectType->getIsIdLegend()) {
$mapObject->setLegend($answer->getId());
}
$mapObjectType->addMapObject($mapObject);
$mapObjectRepository->save($mapObject, true);
$mapObjectTypeRepository->save($mapObjectType, true);
$this->map_objectsPersister->insertOne($mapObject);
}
}
//FDC55 Fence
if ($form->getEntity()->getId() == 23) {
if ($form->getIsLinkedToObject()) {
// modification publication step 2,3,4
$fdc55Fence->updateFenceObject($answer, $mapObjectLinked);
}
// Mail validation initiale
$fdc55Fence->mailStepOneInitial($answer);
}
//FDC77
if ($form->getEntity()->getId() == 7) {
if ($form->getIsLinkedToObject()) {
// modification publication step 2,3,4
$fdc77Fence->updateFenceObject($answer, $mapObjectLinked);
}
// Mail validation initiale
$fdc77Fence->mailStepOneInitial($answer);
$fdc77Agrainage->mailStepOneInitial($answer);
}
//FDC27 Fence
if ($form->getEntity()->getId() == 10) {
if ($form->getIsLinkedToObject()) {
// modification publication step 2
$fdc27Fence->actionOnFenceObject($answer, $mapObjectLinked);
}
// Mail validation initiale
$fdc27Fence->mailStepOneInitial($answer);
}
}
return new JsonResponse(json_encode(true, JSON_THROW_ON_ERROR), 200, [], true);
}
// /**
// *test upload Files.
// * @Rest\Get("/api-import")
// * @param DepartmentRepository $departmentRepository
// * @param RegionRepository $regionRepository
// * @param CityRepository $cityRepository
// * @param AnimalRepository $animalRepository
// * @return JsonResponse
// */
// public function importBase(DepartmentRepository $departmentRepository, RegionRepository $regionRepository, CityRepository $cityRepository, AnimalRepository $animalRepository): JsonResponse
// {
// set_time_limit(0);
// $entityManager = $this->getDoctrine()->getManager();
// $entityManager->getConfiguration()->setSQLLogger(null);
// $regions = $this->exportData($this->getParameter('kernel.project_dir') . "/public/assets/import/regions.csv");
// foreach ($regions as $region) {
// $code = $regionRepository->findOneByCode($region[0]);
// if (!$code) {
// $newRegion = new Region();
// $newRegion->setCode($region[0]);
// $newRegion->setName($region[1]);
// $entityManager->persist($newRegion);
// }
// }
// $entityManager->flush();
//
// $departments = $this->exportData($this->getParameter('kernel.project_dir') . "/public/assets/import/departments.csv");
// foreach ($departments as $department) {
// $code = $departmentRepository->findOneByCode($department[0]);
// if (!$code) {
// $newDepartment = new Department();
// $newDepartment->setCode($department[0]);
// $newDepartment->setName($department[1]);
// $entityManager->persist($newDepartment);
// }
// }
//
// $entityManager->flush();
// $cities = $this->exportData($this->getParameter('kernel.project_dir') . "/public/assets/import/cities.csv");
// $department = null;
// $region = null;
// $last = null;
// foreach ($cities as $key => $city) {
// $code = $cityRepository->findOneByCode($city[0]);
// if (!$code) {
// $newCity = new City();
// $newCity->setCode($city[0]);
// $newCity->setPostalName($city[1]);
// $newCity->setPostalCode($city[2]);
// $newCity->setName($city[3]);
//
// if (!$department)
// $department = $departmentRepository->findOneByCode($city[4]);
// else {
// if ($city[4] != $department->getCode())
// $department = $departmentRepository->findOneByCode($city[4]);
// }
// $newCity->setDepartment($department);
//
// if (!$region)
// $region = $regionRepository->findOneByCode($city[5]);
// else {
// if ($city[5] != $region->getCode())
// $region = $regionRepository->findOneByCode($city[5]);
// }
// $newCity->setRegion($region);
// if ($region && $department)
// $entityManager->persist($newCity);
// }
// if ($key % 100 == 1) {
// $entityManager->flush();
// }
// }
// $animals = $this->exportData($this->getParameter('kernel.project_dir') . "/public/assets/import/animals.csv");
//
// foreach ($animals as $animal) {
// $name = $animalRepository->findOneByName($animal[0]);
// if (!$name) {
// $newAnimal = new Animal;
// $newAnimal->setName($animal[0]);
// $entityManager->persist($newAnimal);
// }
// }
// $entityManager->flush();
// return new JsonResponse(json_encode(true), 200, [], true);
// }
#[Rest\Get('/api-notification-feed')]
public function getUserNotifications(Request $request, SavedNotificationRepository $notificationRepository): JsonResponse
{
$limit = $request->query->get('limit', 20);
$offset = $request->query->get('offset', 0);
$user = $this->getUser();
if (!$user) {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
}
$notifications = SavedNotificationSerialization::serializeSavedNotifications($notificationRepository->findByUser($user, $limit, $offset));
return new JsonResponse(json_encode($notifications, JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('api-like-action')]
public function getUserLikeAnswer(Request $request, AnswerRepository $answerRepository,
NotificationService $notificationService, LikeRepository $likeRepository): JsonResponse
{
$user = $this->getUser();
if (!$user) {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
}
$answer = $answerRepository->findOneById($request->query->get('answer'));
if ($answer) {
$likes = $answer->getLikes();
$find = false;
foreach ($likes as $like) {
if ($like->getAuthor() == $user) {
$find = $like;
}
}
if (!$find) {
$like = new Like();
$like->setAuthor($user);
$like->setAnswer($answer);
$likeRepository->add($like, false);
$title = "Votre publication a été aimée";
$body = "Votre publication a été aimée par " . $user->getLastName() . " " . $user->getName();
$data = ["type" => "answer",
"id" => $answer->getId()];
if ($answer->getAuthor()->getNotifParams()->getNewLike() && $user != $answer->getAuthor()) {
$notificationService->sendUniqueNotification($answer->getAuthor(), $title, $body, $data);
}
$answerRepository->add($answer, true);
} else {
$likeRepository->remove($find, true);
}
}
return new JsonResponse(json_encode(true, JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Post('api-comment-action')]
public function postUserCommentAnswer(Request $request, AnswerRepository $answerRepository,
NotificationService $notificationService, CommentRepository $commentRepository): JsonResponse
{
$user = $this->getUser();
if (!$user) {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
}
$answer = $answerRepository->findOneById($request->request->get('answer'));
if ($answer) {
$comment = new Comment();
$comment->setAuthor($user);
$comment->setDate(new \DateTime());
$comment->setContent($request->request->get('content', ""));
$comment->setAnswer($answer);
$commentRepository->add($comment, true);
$title = "Votre publication a été commentée";
$body = "Votre publication a été commentée par " . $user->getLastName() . " " . $user->getName();
$data = ["type" => "answer",
"id" => $answer->getId()];
if ($answer->getAuthor()->getNotifParams()->getNewComment()) {
$notificationService->sendUniqueNotification($answer->getAuthor(), $title, $body, $data);
}
return new JsonResponse(json_encode(CommentSerialization::serializeComment($comment), JSON_THROW_ON_ERROR), 200, [], true);
}
return new JsonResponse(json_encode(true, JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('api-get-delete-comment-action')]
public function getUserDeleteCommentAnswer(Request $request, CommentRepository $commentRepository): JsonResponse
{
$user = $this->getUser();
if (!$user) {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
}
$comment = $commentRepository->findOneById($request->query->get('comment'));
if ($comment) {
if ($comment->getAuthor() == $user) {
$commentRepository->add($comment, true);
} else {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
}
}
return new JsonResponse(json_encode(true, JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('api-forget-password')]
public function forgotPassword(Request $request, UserRepository $userRepository, TokenGeneratorInterface $tokenGenerator, MailerService $mailerService): JsonResponse
{
$login = $request->query->get('login');
$user = $userRepository->findOneByEmail($login);
if (!$user)
return new JsonResponse(json_encode('forbidden'), 403, [], true);
$token = $tokenGenerator->generateToken();
try {
$user->setResetToken($token);
$userRepository->add($user, true);
} catch (\Exception) {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
}
$url = $this->generateUrl('app_reset_password', ['token' => $token]);
$url = sprintf(
"%s://%s%s",
isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] != 'off' ? 'https' : 'http',
$_SERVER['SERVER_NAME'],
$url
);
$mailerService->sendEmail($user->getEmail(),
"Réinitialisation de mot de passe",
$this->renderView(
'email/forget-password.html.twig',
[
'user' => $user,
'url' => $url]
));
return new JsonResponse(json_encode(true, JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Post('/api-notification-params')]
public function postUserParams(Request $request, NotifParamsRepository $notifParamsRepository): JsonResponse
{
if (!$this->getUser()) {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
}
if (!$this->getUser()->getNotifParams()) {
$notifParams = new NotifParams();
$notifParams->setUser($this->getUser());
} else {
$notifParams = $this->getUser()->getNotifParams();
}
$notifParams->setNewFormEmail(json_decode((string)$request->get("newFormEmail", false), null, 512, JSON_THROW_ON_ERROR));
$notifParams->setNewFormPush(json_decode((string)$request->get("newFormPush", false), null, 512, JSON_THROW_ON_ERROR));
$notifParams->setNewPublication(json_decode((string)$request->get("newPublication", false), null, 512, JSON_THROW_ON_ERROR));
$notifParams->setNewLike(json_decode((string)$request->get("like", false), null, 512, JSON_THROW_ON_ERROR));
$notifParams->setNewComment(json_decode((string)$request->get("comment", false), null, 512, JSON_THROW_ON_ERROR));
$notifParams->setEntityApproval(json_decode((string)$request->get("entityApproval", false), null, 512, JSON_THROW_ON_ERROR));
$notifParamsRepository->add($notifParams, true);
return new JsonResponse(json_encode(NotifParamsSerialization::serializeNotifParams($notifParams), JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Post('/api-log')]
public function postLog(Request $request, LogRepository $logRepository): JsonResponse
{
// if (!$this->getUser()){
// return new JsonResponse(json_encode('forbidden'), 403, [], true);
// }
$params = $request->request->all();
$params['date'] = explode("/", (string)$params['date']);
$params["date"] = $params["date"][1] . "/" . $params["date"][0] . "/" . $params["date"][2];
$log = new Log();
$log->setDate(new \DateTime($params['date']));
if ($this->getUser()) {
$log->setUser($this->getUser());
}
$log->setPhoneModel($params['phoneModel']);
$log->setLog($params['log']);
$log->setPlatform($params['platform']);
$log->setVersionOs($params['versionOs']);
$log->setApplicationVersion($params['applicationVersion']);
$logRepository->add($log, true);
return new JsonResponse(json_encode("logs has been sent"), 200, [], true);
}
// /**
// * @Rest\Get("api-clean-database")
// * @param EntityRepository $entityRepository
// * @return JsonResponse
// */
// public function cleanDatabase(EntityRepository $entityRepository): JsonResponse
// {
// $entityManager = $this->getDoctrine()->getManager();
// $entity = $entityRepository->findOneById(7);
// $forms = $entity->getform();
// foreach ($forms as $form){
// foreach($form->getAnswers() as $answer){
// $entityManager->remove($answer);
// }
//
// } $entityManager->flush();
// $entityManager = $this->getDoctrine()->getManager();
// return new JsonResponse(json_encode(true), 200, [], true);
// }
#[Rest\Get('api-anonyme-everywhere')]
public function anonymeEverywhere(UserRepository $userRepository,
EntityRepository $entityRepository,
ProfileRepository $profileRepository, UserEntityRepository $userEntityRepository): JsonResponse
{
$user = $userRepository->findOneByEmail("anonyme@anonyme.fr");
$entities = $entityRepository->findAll();
$profiles = $profileRepository->findAll();
foreach ($entities as $entity) {
$userEntity = new UserEntity();
$userEntity->setUser($user);
$userEntity->setEntity($entity);
$userEntity->setIsAccepted(true);
$userEntityRepository->add($userEntity, false);
}
foreach ($profiles as $profile) {
$user->addProfile($profile);
}
$userRepository->add($user, true);
return new JsonResponse(json_encode(true, JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('/api-delete-user')]
public function deleteUserAction(UserRepository $userRepository, MapObjectRepository $mapObjectRepository): JsonResponse
{
$user = $this->getUser();
if (!$user) {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
}
foreach ($user->getAnswers() as $answer) {
$answer->setAuthor($userRepository->findOneByEmail("anonyme@anonyme.fr"));
// Update Elasticsearch
}
if (!$user->getAnswers()->isEmpty()) {
$this->answersPersister->replaceMany($user->getAnswers()->getValues());
}
$mapObjects = $mapObjectRepository->findByUser($user);
if (!empty($mapObjects)) {
$this->map_objectsPersister->replaceMany($mapObjects);
}
$userRepository->remove($user, true);
$session = $this->container->get('request_stack')->getSession();
$session->invalidate();
return new JsonResponse(json_encode('deleted'), 200, [], true);
}
#[Rest\Get('/api-booking-forms')]
public function findBookingsByEntity(Request $request, FormRepository $formRepository): JsonResponse
{
return new JsonResponse(
json_encode(
FormSerialization::serializeForms(
$formRepository->findBooking()), JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('api-booking-form-places')]
public function findNumberOfPlacesAvailable(Request $request, AnswerContentRepository $answerContentRepository, FormRepository $formRepository): JsonResponse
{
$field = $request->query->get('field');
$form = $request->query->get('form');
$answers = $answerContentRepository->findBy(['field' => $field]);
$places = $formRepository->findOneBy(['id' => $form]);
$placesAvailable = '';
if ($answers) {
// Subtract number of available places
$i = 0;
foreach ($answers as $answer) {
$i = $i + $answer->getContent();
}
$placesAvailable = $places->getNumberBooking() - $i;
} else {
// Display number places origin
$placesAvailable = $places->getNumberBooking();
}
return new JsonResponse(json_encode($placesAvailable, JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('api-booking-user')]
public function findAnswersBookingUser(LineRepository $lineRepository): JsonResponse
{
$user = $this->getUser();
$answers = $user->getAnswers();
$results = [];
foreach ($answers as $answer) {
if ($answer->getForm()->getIsBooking()) {
$results[] = $answer;
}
}
return new JsonResponse(json_encode(AnswerSerialization::serializeFeedAnswers($results, null, null, $lineRepository), JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('api-delete-answer-user')]
public function deleteAnswerUser(Request $request, AnswerRepository $answerRepository,
MailerService $email, AnswerContentRepository $answerContentRepository,
FormRepository $formRepository, UserRepository $userRepository, MapObjectRepository $mapObjectRepository): JsonResponse
{
$user = $this->getUser();
$answer = $answerRepository->findOneBy(['id' => $request->query->get('answer')]);
if ($answer->getAuthor() == $user) {
if($answer->getMapObject()){
$mapObjectRepository->remove($answer->getMapObject(), true);
}
$answerRepository->remove($answer, true);
if ($answer->getForm()->getIsBooking()) {
$admins = $answer->getForm()->getEntity()->getAdmins();
$form = $answer->getForm();
$answersContents = $answer->getAnswerContents();
$places = $formRepository->findOneBy(['id' => $answer->getForm()]);
$field = $answersContents[0]->getField();
$answers = $answerContentRepository->findBy(['field' => $field]);
$i = 0;
// Subtract number of available places
foreach ($answers as $answer) {
$i = $i + $answer->getContent();
}
$placesAvailable = $places->getNumberBooking() - $i;
$email->deleteBookingUser($admins, $user, $placesAvailable, $form);
}
return new JsonResponse(json_encode(true, JSON_THROW_ON_ERROR), 200, [], true);
} else {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
}
}
#[Rest\Post('/api-search-forms')]
public function searchForms(Request $request, FormRepository $formRepository, AnswerRepository $answerRepository, AnimalRepository $animalRepository, Geocoder $geocoder): JsonResponse
{
$data = json_decode($request->getContent(), true, 512, JSON_THROW_ON_ERROR);
$startDate = $data['params']['startDate'];
$endDate = $data['params']['endDate'];
$animals = $data['params']['animals'];
$profiles = $data['params']['profiles'];
$entities = $data['params']['entities'];
$statut = $data['params']['statut'];
$mapObjectType = $data['params']['mapObjectTypes'];
if (!$entities) {
$entities[] = $this->getUser()->getSelectedEntity()->getId();
}
//Get all answers relative to parameters
$answers = $answerRepository->findAnswersByFieldsTypeAnimals($entities, $profiles, $statut, $startDate, $endDate, $animals, $mapObjectType);
//Group by form
$results = [];
foreach ($answers as $answer) {
$form = $answer->getForm();
if (!array_key_exists($form->getId(), $results)) {
$results[$form->getId()]["title"] = $form->getTitle();
$results[$form->getId()]["isBooking"] = $form->getIsBooking();
$results[$form->getId()]["isGeolocated"] = $form->getIsGeolocated() || $form->getIsShape();
$results[$form->getId()]["answers"] = [];
$results[$form->getId()]["answers"][] = AnswerSerialization::serializeExportAnswer($answer, $animalRepository, $geocoder, $this->getUser());
} else {
$results[$form->getId()]["answers"][] = AnswerSerialization::serializeExportAnswer($answer, $animalRepository, $geocoder, $this->getUser());
}
}
return new JsonResponse(json_encode($results, JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('/api-get-all-answers')]
public function getAllAnswersForForm(Request $request, FormRepository $formRepository,
LineRepository $lineRepository, AnswerRepository $answerRepository): JsonResponse
{
$formId = $request->query->get('form');
$form = $formRepository->find(['id' => $formId]);
$results = AnswerSerialization::serializeAdminTabAnswers($form->getAnswers(), null, false, $this->encryptor, $lineRepository, $answerRepository);
return new JsonResponse(json_encode($results, JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('/api-get-statuts-answer')]
public function getStatutsAnswer(StatutAnswerRepository $statutAnswerRepository): JsonResponse
{
$result = [];
foreach ($statutAnswerRepository->findAll() as $statutAnswer) {
$result[] = [
'id' => $statutAnswer->getId(),
'name' => $statutAnswer->getName()
];
}
return new JsonResponse(json_encode($result, JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Post('/api-post-valid-answer')]
public function postValidAnswer(Request $request, AnswerRepository $answerRepository, StatutAnswerRepository $statutAnswerRepository): JsonResponse
{
$data = json_decode($request->getContent(), true, 512, JSON_THROW_ON_ERROR);
$answer = $answerRepository->findOneBy(['id' => $this->encryptor->decrypt($data['params']['answer'])]);
$statut = $statutAnswerRepository->findOneBy(['id' => $data['params']['statut']]);
$answer->setStatut($statut);
try {
$answerRepository->add($answer, true);
return new JsonResponse(json_encode(true, JSON_THROW_ON_ERROR), 200, [], true);
} catch (\Exception $e) {
return new JsonResponse(json_encode("Erreur dans le post d'une réponse, le serveur à renvoyé l'exception suivante ${$e}", JSON_THROW_ON_ERROR), 500, [], true);
}
}
#[Rest\Get('/api-delete-answer')]
public function getDeleteAnswer(Request $request, AnswerRepository $answerRepository, MapObjectRepository $mapObjectRepository): JsonResponse
{
$user = $this->getUser();
if (!$user) {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
} else {
$answerId = $request->query->get('answer');
$answer = $answerRepository->findOneBy(['id' => $answerId]);
$entities = [];
$allowed = false;
$answerAuthor = $answer->getAuthor();
if ($user == $answerAuthor) {
$allowed = true;
} elseif (in_array('ROLE_SUPER_ADMIN', $user->getRoles())) {
$allowed = true;
} elseif (in_array('ROLE_ADMIN', $user->getRoles())) {
$adminEntities = $user->getEntitiesAdmins();
foreach ($adminEntities as $adminEntity) {
$entities[] = $adminEntity->getName();
}
$allowed = in_array($answer->getForm()->getEntity()->getName(), $entities);
}
if ($allowed) {
$medias = $answer->getMedias();
if ($medias) {
foreach ($medias as $media) {
$answer->removeMedia($media);
}
}
if($answer->getMapObject()){
$mapObjectRepository->remove($answer->getMapObject(), true);
}
$answerRepository->remove($answer, true);
return new JsonResponse(json_encode(true, JSON_THROW_ON_ERROR), 200, [], true);
} else {
return new JsonResponse(json_encode("Erreur lors de la suppression d'un post, l'utilisateur n'est pas l'auteur du post"), 403, [], true);
}
}
}
#[Rest\Post('/api-encrypt')]
public function postEncrypt(Request $request): JsonResponse
{
$data = json_decode($request->getContent(), true, 512, JSON_THROW_ON_ERROR);
$encrypted = $this->encryptor->encrypt($data['params']['encrypt']);
return new JsonResponse(json_encode(['encrypted' => $encrypted], JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('/api-extended-view')]
public function answersExtendedViewTable(Request $request, FormRepository $formRepository,
AnimalRepository $animalRepository, LineRepository $lineRepository, AnswerRepository $answerRepository): JsonResponse
{
$formId = $request->query->get('form');
$form = $formRepository->findOneBy(['id' => $formId]);
$result = [];
$result["fields"] = [];
foreach ($form->getFields() as $field) {
$result["fields"][] = ['title' => $field->getTitle()];
}
$result['answers'] = AnswerSerialization::serializeAdminTabAnswers($form->getAnswers(), $animalRepository, true, $this->encryptor, $lineRepository, $answerRepository);
return new JsonResponse(json_encode($result, JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('/api-shape-has-point')]
public function getShape_has_point(Request $request, ShapeHasPointRepository $hasPointRepository): JsonResponse
{
$shapesHasPoint = $hasPointRepository->findBy(['shape' => $request->query->get('id')]);
$result = [];
$result["shapeType"] = $shapesHasPoint[0]->getShape()->getType();
$result["points"] = [];
foreach ($shapesHasPoint as $shapeHasPoint) {
$result["points"][] = [
$shapeHasPoint->getLat(),
$shapeHasPoint->getLng()
];
}
return new JsonResponse(json_encode($result, JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('/api-report-map')]
public function getReportMap(Request $request, AnswerRepository $answerRepository): JsonResponse
{
if (!$this->getUser()) {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
} else {
$swLat = $request->query->get('swLat', false);
$swLng = $request->query->get('swLng', false);
$neLat = $request->query->get('neLat', false);
$neLng = $request->query->get('neLng', false);
$id = $request->query->get('id', null);
$web = filter_var($request->query->get('web', false), FILTER_VALIDATE_BOOLEAN);;
if ($swLat && $swLng && $neLat && $neLng) {
// $answers = $answerRepository->findAllByUser($this->getUser(), $swLat, $swLng, $neLat, $neLng);
$answers = $this->answersElastica(false, 0, 0, $swLat, $swLng, $neLat, $neLng, $web, $id);
// $answers = AnswerSerialization::serializeMapAnswers($answers);
return new JsonResponse(json_encode($answers, JSON_THROW_ON_ERROR), 200, [], true);
} else {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
}
}
}
#[Rest\Get('/api-entity-category')]
public function getEntityCategories(Request $request, CategoryRepository $categoryRepository): JsonResponse
{
if (!$this->getUser()) {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
} else {
return new JsonResponse(
json_encode(
CategorySerialization::serializeCategorys(
$categoryRepository->findByEntity($this->getUser()->getSelectedEntity())
), JSON_THROW_ON_ERROR
), 200, [], true);
}
}
#[Rest\Get('/api-clean-geoloc')]
public function getCleanGeoloc(Request $request, AnswerRepository $answerRepository, Geocoder $geocoder, CityRepository $cityRepository): JsonResponse
{
$answer = null;
if ($this->role === "ROLE_SUPER_ADMIN") {
$answers = $answerRepository->findAll();
foreach ($answers as $answer) {
if ($answer->getGeolocation()) {
if ($answer->getGeolocation()->getLat() && $answer->getGeolocation()->getLng()) {
$city = $geocoder->reverseGeocode($answer->getGeolocation()->getLat(), $answer->getGeolocation()->getLng());
$answer->getGeolocation()->setFullAddress($city["fullAdress"]);
if (!is_null($answer->getGeolocation()->getCity())) {
if (array_key_exists("ville", $city)) {
$city = $city['ville'];
$city = $cityRepository->findOneByCityName($city);
if ((is_countable($city) ? count($city) : 0) > 0) {
$answer->getGeolocation()->setCity($city[0]);
}
}
}
}
}
}
$answerRepository->add($answer, true);
}
return new JsonResponse(json_encode(true, JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('/api-user-validated')]
public function getUserValidated(): JsonResponse
{
if (!$this->getUser()) {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
} else {
if ($this->role == "ROLE_ADMIN" || $this->role == "ROLE_SUPER_ADMIN")
$validated = true;
else {
$validated = false;
foreach ($this->getUser()->getUserEntities() as $userEntity) {
if ($userEntity->getIsAccepted()) {
$validated = true;
}
}
}
return new JsonResponse(json_encode($validated, JSON_THROW_ON_ERROR), 200, [], true);
}
}
#[Rest\Get('/update-users-notif-params')]
public function updateUsersNotificationParams(UserRepository $userRepository): JsonResponse
{
if ($this->role === "ROLE_SUPER_ADMIN" && $this->getUser()) {
foreach ($userRepository->findAll() as $user) {
if ($user->getNotifParams() == null) {
$user->setNotifParams(new NotifParams());
$userRepository->add($user, true);
}
}
}
return new JsonResponse(json_encode(true, JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('/api-is-admin')]
public function getIsAdmin(): JsonResponse
{
if ($this->role === "ROLE_ADMIN") {
return new JsonResponse(json_encode(true, JSON_THROW_ON_ERROR), 200, [], true);
} else {
return new JsonResponse(json_encode(false, JSON_THROW_ON_ERROR), 200, [], true);
}
}
#[Rest\Get('/api-notification-params')]
public function getUserNotificationParams(): JsonResponse
{
$notifParams = $this->getUser()->getNotifParams();
return new JsonResponse(json_encode(NotifParamsSerialization::serializeNotifParams($notifParams), JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('/api-test-notification')]
public function getTestNotification(Request $request, NotificationService $notificationService): JsonResponse
{
$identifier = $request->query->get('identifier');
return new JsonResponse(json_encode($notificationService->sendTestNotification($identifier, "test", "test", ["test" => "test"]), JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('/api-clean-shape')]
public function getCleanShape(ShapeRepository $shapeRepository): JsonResponse
{
if ($this->role === "ROLE_SUPER_ADMIN") {
$shapes = $shapeRepository->findAll();
foreach ($shapes as $shape) {
if ($shape->getType() == null) {
$shape->setType("polygon");
$shapeRepository->add($shape, true);
}
}
}
return new JsonResponse(json_encode(true, JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('/api-testemail')]
public function testEmail(MailerService $mailer): JsonResponse
{
$mailer->sendEmail();
return new JsonResponse(json_encode(true, JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('/api-read-notification')]
public function getReadNotification(Request $request, NotificationService $notificationService, SavedNotificationRepository $savedNotificationRepository): JsonResponse
{
$notification = $request->query->get('notification');
$notification = $savedNotificationRepository->findOneById($notification);
if (!$this->getUser() || !$notification) {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
}
if ($this->getUser() != $notification->getUser()) {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
}
$notification->setIsReaded(true);
$savedNotificationRepository->add($notification, true);
return new JsonResponse(json_encode(true, JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('/api-clean-double')]
public function getCleanDouble(AnswerRepository $answerRepository,
LikeRepository $likeRepository,
CommentRepository $commentRepository): JsonResponse
{
$answer = null;
if ($this->role === "ROLE_SUPER_ADMIN") {
$answers = $answerRepository->findDouble();
foreach ($answers as $answer) {
$doubles = $answerRepository->isDouble($answer->getAuthor(), $answer->getDate());
$double1 = $doubles[0];
$double2 = $doubles[1];
foreach ($double2->getLikes() as $likeDouble2) {
$find = false;
foreach ($double1->getLikes() as $likeDouble1) {
if ($likeDouble1->getAuthor() == $likeDouble2->getAuthor()) {
$find = true;
}
}
if (!$find) {
$likeDouble2->setAnswer($double1);
$likeRepository->add($likeDouble2, false);
}
}
foreach ($double2->getComments() as $comment) {
$comment->setAnswer($double1);
$commentRepository->add($comment, false);
}
$likeRepository->add($double2, false);
}
$answerRepository->add($answer, true);
}
return new JsonResponse(json_encode(true, JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('/api-map-icon')]
public function getMapIcon(): JsonResponse
{
return new JsonResponse(json_encode(array_diff(scandir($this->getParameter('kernel.project_dir') . "/public/assets/img/icons"), ['.', '..', 'default_icon.png']), JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Post('/api-object-type')]
public function postObjectType(Request $request, FormRepository $formRepository,
FieldRepository $fieldRepository, MapObjectTypeRepository $mapObjectTypeRepository,
MapObjectRepository $mapObjectRepository, AnswerContentRepository $answerContentRepository,
GeolocationRepository $geolocationRepository, ShapeHasPointRepository $shapeHasPointRepository,
ShapeRepository $shapeRepository): JsonResponse
{
$data = json_decode($request->getContent(), true, 512, JSON_THROW_ON_ERROR)['params'];
$mapObjectType = new MapObjectType();
$mapObjectType->setTitle($data['title']);
$mapObjectType->setColor($data['color']);
$mapObjectType->setDescription($data['description']);
if ($data['icon'] != "") {
$mapObjectType->setIcon($data['icon']);
}
$form = $formRepository->findOneBy(['id' => $data['form']]);
if ($data['legend'] != 'no' && $data['legend'] != 'id') {
$field = $fieldRepository->findOneBy(['id' => $data['legend']]);
$mapObjectType->setLegendField($field);
}
$mapObjectType->setForm($form);
$mapObjectType->setEntity($form->getEntity());
$form->setIsObject(true);
$mapObjectTypeRepository->save($mapObjectType, true);
foreach ($form->getAnswers() as $answer) {
$mapObject = new MapObject();
$geolocation = new Geolocation();
$geolocation->setLat($answer->getGeolocation()->getLat());
$geolocation->setLng($answer->getGeolocation()->getLng());
$geolocation->setCity($answer->getGeolocation()->getCity());
$geolocationRepository->add($geolocation, false);
$mapObject->setGeolocation($geolocation);
$mapObjectShape = new Shape();
$mapObjectShape->setType($answer->getShape()->getType());
foreach($answer->getShape()->getShapeHasPoints() as $shapeHasPoint){
$newShapeHasPoint = new ShapeHasPoint();
$newShapeHasPoint->setLat($shapeHasPoint->getLat());
$newShapeHasPoint->setLng($shapeHasPoint->getLng());
$newShapeHasPoint->setShape($mapObjectShape);
$shapeHasPointRepository->add($newShapeHasPoint, false);
$mapObjectShape->addShapeHasPoint($newShapeHasPoint);
}
$shapeRepository->add($mapObjectShape, false);
$mapObject->setShape($mapObjectShape);
$mapObject->setAnswer($answer);
if ($data['legend'] != 'no' && $data['legend'] != 'id') {
$mapObjectType->setIsIdLegend(false);
$answerContent = $answerContentRepository->findOneBy(['answer' => $answer, 'field' => $field]);
if ($answerContent?->getContent()) {
$mapObject->setLegend($answerContent->getContent());
} else {
$mapObject->setLegend($answer->getId());
}
} elseif ($data['legend'] == 'id') {
$mapObjectType->setIsIdLegend(true);
$mapObject->setLegend($answer->getId());
}
$mapObjectType->addMapObject($mapObject);
$mapObjectRepository->save($mapObject);
}
$mapObjectTypeRepository->save($mapObjectType, true);
return new JsonResponse(json_encode("true", JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Post('/api-edit-object-type')]
public function postEditObjectType(Request $request, FormRepository $formRepository,
FieldRepository $fieldRepository, MapObjectTypeRepository $mapObjectTypeRepository,
MapObjectRepository $mapObjectRepository, AnswerContentRepository $answerContentRepository): JsonResponse
{
$data = json_decode($request->getContent(), true, 512, JSON_THROW_ON_ERROR)['params'];
$mapObjectType = $mapObjectTypeRepository->findOneBy(['id' => $data['id']]);
$mapObjectType->setTitle($data['title']);
$mapObjectType->setColor($data['color']);
$mapObjectType->setDescription($data['description']);
if ($data['icon'] != "") {
$mapObjectType->setIcon($data['icon']);
}
if ($data['legend'] != 'no' && $data['legend'] != 'id') {
$mapObjectType->setIsIdLegend(false);
$field = $fieldRepository->findOneBy(['id' => $data['legend']]);
$mapObjectType->setLegendField($field);
if ($field !== $mapObjectType->getLegendField()) {
$mapObjectType->setLegendField($field);
foreach ($mapObjectType->getMapObjects() as $mapObject) {
$answerContent = $answerContentRepository->findOneBy(['answer' => $mapObject->getAnswer(), 'field' => $field]);
if ($answerContent?->getContent()) {
$mapObject->setLegend($answerContent->getContent());
} else {
$mapObject->setLegend($mapObject->getAnswer()->getId());
}
}
}
} elseif ($data['legend'] == 'id') {
$mapObjectType->setIsIdLegend(true);
foreach ($mapObjectType->getMapObjects() as $mapObject) {
$mapObject->setLegend($mapObject->getAnswer()->getId());
}
} else {
$mapObjectType->setIsIdLegend(false);
$mapObjectType->setLegendField(null);
foreach ($mapObjectType->getMapObjects() as $mapObject) {
$mapObject->setLegend(null);
}
}
$mapObjectTypeRepository->save($mapObjectType, true);
return new JsonResponse(json_encode("true", JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('/api-entity-object-type')]
public function getEntityObjectTypes(Request $request, MapObjectTypeRepository $mapObjectTypeRepository): JsonResponse
{
if (!$this->getUser()) {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
} else {
return new JsonResponse(
json_encode(
MapObjectTypeSerialization::serializeMapObjectTypes(
$mapObjectTypeRepository->findByEntity($this->getUser()->getSelectedEntity())
), JSON_THROW_ON_ERROR
), 200, [], true);
}
}
public function answersElastica(bool $feed = true, int $limit = 50, int $offset = 0, string|null $swLat = null, string|null $swLng = null, string|null $neLat = null, string|null $neLng = null, $web = false, string|null $id = null): array
{
$answersFinder = $this->answersFinder;
$user = $this->getUser();
$resultQuery = new BoolQuery();
if (in_array('ROLE_SUPER_ADMIN', $user->getRoles())) {
$maxLimit = 100;
} else {
$paramsAnswersQuery = [];
$entities = [];
$maxLimit = 50;
$tempEntityQuery = new BoolQuery();
$entityQuery = new BoolQuery();
//admin entities
if (in_array('ROLE_ADMIN', $user->getRoles())) {
$answersAdminEntityQuery = new BoolQuery();
foreach ($user->getEntitiesAdmins() as $entitiesAdmin) {
// Display all answers for his entity because is admin
$answersAdminEntityQuery->addShould(new Query\Term(['form.entity.id' => $entitiesAdmin->getId()]));
$entities[] = $entitiesAdmin->getId();
}
$answerAdminQuery = new Boolquery();
$answerAdminQuery->addMust($answersAdminEntityQuery);
$tempEntityQuery->addShould($answerAdminQuery);
// Add admin answer (just in case)
$tempEntityQuery->addShould(new Query\Term(['author.id' => $user->getId()]));
} else {
// Hidden answer not public except your answers
$publicUserQuery = new BoolQuery();
$publicUserQuery->addShould(new Query\Term(['form.isPublic' => true]));
$publicUserQuery->addShould(new Query\Term(['author.id' => $user->getId()]));
$publicQuery = new BoolQuery();
$publicQuery->addMust($publicUserQuery);
$paramsAnswersQuery[] = $publicQuery;
}
//Entity where user is not admin
$authorized = false;
foreach ($user->getUserEntities() as $userEntity) {
if (!in_array($userEntity->getEntity()->getId(), $entities)) {
$formsProfileQuery = new BoolQuery();
$tempFormsProfileQuery = new BoolQuery();
if ($userEntity->getIsAccepted()) {
foreach ($user->getProfiles() as $profile) {
$profilesQuery = new BoolQuery();
$profilesQuery->addMust(new Query\Term(['form.profiles.id' => $profile->getId()]));
$profilesQuery->addMust(new Query\Term(['form.entity.id' => $userEntity->getEntity()->getId()]));
$tempFormsProfileQuery->addShould($profilesQuery);
}
$noProfilesQuery = new BoolQuery();
$noProfilesQuery->addMustNot(new Query\Exists('form.profiles'));
$noProfilesQuery->addMust(new Query\Term(['form.entity.id' => $userEntity->getEntity()->getId()]));
$tempFormsProfileQuery->addShould($noProfilesQuery);
$formsProfileQuery->addMust($tempFormsProfileQuery);
$tempEntityQuery->addShould($formsProfileQuery);
$authorized = true;
}
}
}
//If not authorized and not admin
if (!$authorized && !in_array('ROLE_ADMIN', $user->getRoles())) {
$formAuthorQuery = new BoolQuery();
$formAuthorQuery->addMust(new Query\Term(['author.id' => $user->getId()]));
$paramsAnswersQuery[] = $formAuthorQuery;
}
$entityQuery->addMust($tempEntityQuery);
$paramsAnswersQuery[] = $entityQuery;
$resultQuery->addMust($paramsAnswersQuery);
}
// Hidden isBooking
$resultQuery->addMust(new Query\Term(['form.isBooking' => false]));
// Hidden not active
$resultQuery->addMust(new Query\Term(['form.isActive' => true]));
$resultQuery->addMust(new Query\Term(['isActive' => true]));
// If map display
if ($swLat && $swLng && $neLat && $neLng) {
$posAnswersQuery = new BoolQuery();
$posAnswersQuery->addMust(new Range('geolocation.lat', [
'gte' => (float)$swLat,
'lte' => (float)$neLat
]));
$posAnswersQuery->addMust(new Range('geolocation.lng', [
'gte' => (float)$swLng,
'lte' => (float)$neLng
]));
$resultQuery->addMust($posAnswersQuery);
if ($id) {
$resultQuery->addMust(new Query\Term(['form.id' => $id]));
} else {
if (!$web) {
$existMapObject = new Query\Exists('mapObject');
$resultQuery->addMustNot($existMapObject);
}
}
}
$query = new Query($resultQuery);
$query->addSort(['date' => 'desc']);
if ($feed) {
if ($offset == $maxLimit) {
$limit = 0;
}
$query->setSize($limit);
$query->setFrom($offset);
return $answersFinder->find($query);
}
// Return for map
$query->setSource([
'id',
'date',
'author.name', 'author.lastName',
'form.title',
'form.id',
'geolocation.lat', 'geolocation.lng',
'shape']);
$results = $answersFinder->findRaw($query, 100000);
$answers = [];
foreach ($results as $answer) {
$answers[] = $answer->getSource();
}
return $answers;
}
public function mapObjectsElastica(string|null $swLat = null, string|null $swLng = null, string|null $neLat = null, string|null $neLng = null, int|null $id = null): array
{
$mapObjectsFinder = $this->map_objectsFinder;
$user = $this->getUser();
$resultQuery = new BoolQuery();
if (!in_array('ROLE_SUPER_ADMIN', $user->getRoles())) {
$paramsAnswersQuery = [];
$entities = [];
$tempEntityQuery = new BoolQuery();
$entityQuery = new BoolQuery();
//admin entities
if (in_array('ROLE_ADMIN', $user->getRoles())) {
$answersAdminEntityQuery = new BoolQuery();
foreach ($user->getEntitiesAdmins() as $entitiesAdmin) {
// Display all answers for his entity because is admin
$answersAdminEntityQuery->addShould(new Query\Term(['mapObjectType.form.entity.id' => $entitiesAdmin->getId()]));
$entities[] = $entitiesAdmin->getId();
}
$answerAdminQuery = new Boolquery();
$answerAdminQuery->addMust($answersAdminEntityQuery);
$tempEntityQuery->addShould($answerAdminQuery);
// Add admin answer (just in case)
$tempEntityQuery->addShould(new Query\Term(['answer.author.id' => $user->getId()]));
} else {
// Hidden answer not public except your answers
$publicUserQuery = new BoolQuery();
$publicUserQuery->addShould(new Query\Term(['mapObjectType.form.isPublic' => true]));
$publicUserQuery->addShould(new Query\Term(['answer.author.id' => $user->getId()]));
$publicQuery = new BoolQuery();
$publicQuery->addMust($publicUserQuery);
$paramsAnswersQuery[] = $publicQuery;
}
//Entity where user is not admin
$authorized = false;
foreach ($user->getUserEntities() as $userEntity) {
if (!in_array($userEntity->getEntity()->getId(), $entities)) {
$formsProfileQuery = new BoolQuery();
$tempFormsProfileQuery = new BoolQuery();
if ($userEntity->getIsAccepted()) {
foreach ($user->getProfiles() as $profile) {
$profilesQuery = new BoolQuery();
$profilesQuery->addMust(new Query\Term(['mapObjectType.form.profiles.id' => $profile->getId()]));
$profilesQuery->addMust(new Query\Term(['mapObjectType.form.entity.id' => $userEntity->getEntity()->getId()]));
$tempFormsProfileQuery->addShould($profilesQuery);
}
$noProfilesQuery = new BoolQuery();
$noProfilesQuery->addMustNot(new Query\Exists('mapObjectType.form.profiles'));
$noProfilesQuery->addMust(new Query\Term(['mapObjectType.form.entity.id' => $userEntity->getEntity()->getId()]));
$tempFormsProfileQuery->addShould($noProfilesQuery);
$formsProfileQuery->addMust($tempFormsProfileQuery);
$tempEntityQuery->addShould($formsProfileQuery);
$authorized = true;
}
}
}
//If not authorized and not admin
if (!$authorized && !in_array('ROLE_ADMIN', $user->getRoles())) {
$formAuthorQuery = new BoolQuery();
$formAuthorQuery->addMust(new Query\Term(['answer.author.id' => $user->getId()]));
$paramsAnswersQuery[] = $formAuthorQuery;
}
$entityQuery->addMust($tempEntityQuery);
$paramsAnswersQuery[] = $entityQuery;
$resultQuery->addMust($paramsAnswersQuery);
}
// Hidden isBooking
$resultQuery->addMust(new Query\Term(['mapObjectType.form.isBooking' => false]));
// Hidden not active
$resultQuery->addMust(new Query\Term(['mapObjectType.isActive' => true]));
$resultQuery->addMust(new Query\Term(['isActive' => true]));
// If map display
if ($swLat && $swLng && $neLat && $neLng) {
$posAnswersQuery = new BoolQuery();
$posAnswersQuery->addMust(new Range('geolocation.lat', [
'gte' => (float)$swLat,
'lte' => (float)$neLat
]));
$posAnswersQuery->addMust(new Range('geolocation.lng', [
'gte' => (float)$swLng,
'lte' => (float)$neLng
]));
$resultQuery->addMust($posAnswersQuery);
}
// If filter by object type
if ($id) {
$resultQuery->addMust(new Query\Term(['mapObjectType.id' => $id]));
}
$query = new Query($resultQuery);
// Return for map
$query->setSource([
'id',
'isIdInitial',
'legend',
'answer.id',
'answer.date',
'answer.author.name', 'answer.author.lastName',
'mapObjectType.id', 'mapObjectType.title',
'mapObjectType.color', 'mapObjectType.icon',
'geolocation.lat', 'geolocation.lng',
'shape',
'color']);
$results = $mapObjectsFinder->findRaw($query, 100000);
$mapObjects = [];
foreach ($results as $mapObject) {
$mapObjects[] = $mapObject->getSource();
}
return $mapObjects;
}
#[Rest\Get('/api-map-object')]
public function getMapObject(Request $request): JsonResponse
{
if (!$this->getUser()) {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
} else {
$swLat = $request->query->get('swLat', false);
$swLng = $request->query->get('swLng', false);
$neLat = $request->query->get('neLat', false);
$neLng = $request->query->get('neLng', false);
$id = $request->query->get('id', null);
$mapObjects = $this->mapObjectsElastica($swLat, $swLng, $neLat, $neLng, $id);
// $answers = AnswerSerialization::serializeMapAnswers($answers);
return new JsonResponse(json_encode($mapObjects, JSON_THROW_ON_ERROR), 200, [], true);
}
}
#[Rest\Get('/api-map-object-types')]
public function getMapObjectTypes(MapObjectTypeRepository $mapObjectTypeRepository): JsonResponse
{
if (!$this->getUser()) {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
} else {
$mapObjects = $mapObjectTypeRepository->findByUser($this->getUser());
return new JsonResponse(json_encode(MapObjectTypeSerialization::serializeForMapMapObjectTypes($mapObjects, $this->getUser()), JSON_THROW_ON_ERROR), 200, [], true);
}
}
#[Rest\Get('/api-map-object-type')]
public function getMapObjectType(MapObjectTypeRepository $mapObjectTypeRepository, Request $request, AnimalRepository $animalRepository): JsonResponse
{
if (!$this->getUser()) {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
} else {
$mapObjectType = $mapObjectTypeRepository->findOneById($request->query->get('id'));
if ($mapObjectType->getEntity() != $this->getUser()->getSelectedEntity() && $this->role != 'ROLE_SUPER_ADMIN') {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
}
return new JsonResponse(json_encode(MapObjectTypeSerialization::serializeMapObjectTypeForEdit($mapObjectType, $animalRepository), JSON_THROW_ON_ERROR), 200, [], true);
}
}
#[Rest\Get('/api-admin-big-list')]
public function getAdminBigList(BigListRepository $bigListRepository): JsonResponse
{
if (!$this->getUser()) {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
} else {
$bigLists = $bigListRepository->findByEntity($this->getUser()->getSelectedEntity());
return new JsonResponse(json_encode(BigListSerialization::serializeBigLists($bigLists), JSON_THROW_ON_ERROR), 200, [], true);
}
}
#[Rest\Get('/api-big-list')]
public function getBigList(BigListRepository $bigListRepository, EntityRepository $entityRepository): JsonResponse
{
if (!$this->getUser()) {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
} else {
$entities = $entityRepository->getUserAdminEntities($this->getUser()->getId());
foreach ($this->getUser()->getUserEntities() as $userEntity) {
$entities[] = $userEntity->getEntity();
}
$bigLists = $bigListRepository->findByEntities($entities);
return new JsonResponse(json_encode(BigListSerialization::serializeBigListWithLiness($bigLists), JSON_THROW_ON_ERROR), 200, [], true);
}
}
#[Rest\Get('/api-lines/{bigList}')]
public function getLines(BigList $bigList): JsonResponse
{
if (!$this->getUser()) {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
} else {
$lines = $bigList->getListLines();
return new JsonResponse(json_encode(LineSerialization::serializeLines($lines->getValues()), JSON_THROW_ON_ERROR), 200, [], true);
}
}
#[Rest\Get('/api-map-object/{mapObject}/forms')]
public function getMapObjectTypeForms(MapObject $mapObject, FormRepository $formRepository): JsonResponse
{
if (!$this->getUser()) {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
} else {
$forms = $formRepository->findBy(['isActive' => true, 'mapObjectType' => $mapObject->getMapObjectType()]);
return new JsonResponse(json_encode(FormSerialization::serializeFormLinks($forms, $this->encryptor), JSON_THROW_ON_ERROR), 200, [], true);
}
}
#[Rest\Get('/api-clean-answer')]
public function getCleanAnswer(AnswerRepository $answerRepository, EntityManagerInterface $entityManager): JsonResponse
{
set_time_limit(0);
if (!$this->getUser()) {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
} else {
$answers = $answerRepository->findAll();
foreach ($answers as $answer) {
$change = false;
foreach ($answer->getAnswerContents() as $answerContent) {
if ($answerContent->getField()->getForm() != $answer->getForm()) {
$answer->removeAnswerContent($answerContent);
$change = true;
}
}
if ($change)
$answerRepository->add($answer, false);
}
$entityManager->flush();
return new JsonResponse(json_encode(true, JSON_THROW_ON_ERROR), 200, [], true);
}
}
#[Rest\Get('/api-clean-map-object')]
public function getCleanMapObject(MapObjectRepository $mapObjectRepository, EntityManagerInterface $entityManager): JsonResponse
{
set_time_limit(0);
if (!$this->getUser()) {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
} else {
$mapObjects = $mapObjectRepository->findAll();
foreach ($mapObjects as $mapObject) {
if ($mapObject->getAnswer() == null) {
$mapObjectRepository->remove($mapObject, false);
}
}
$entityManager->flush();
return new JsonResponse(json_encode(true, JSON_THROW_ON_ERROR), 200, [], true);
}
}
#[Rest\Get('/api-get-map-object-history')]
public function getMapObjectHistoryAction(Request $request, AnswerRepository $answerRepository,
MapObjectRepository $mapObjectRepository, FieldRepository $fieldRepository,
AnimalRepository $animalRepository, LineRepository $lineRepository): JsonResponse
{
if (!$this->getUser())
return new JsonResponse(json_encode('forbidden'), 403, [], true);
$mapObject = $mapObjectRepository->findOneBy(['id' => $request->query->get('id', null)]);
if (in_array('ROLE_ADMIN', $this->getUser()->getRoles()) || in_array('ROLE_SUPER_ADMIN', $this->getUser()->getRoles())) {
$answers = [];
if ($mapObject->isIsIdInitial()) {
$field = $fieldRepository->findOneBy(['title' => "Id Initial", "form" => $mapObject->getAnswer()->getForm()]);
foreach ($mapObject->getAnswer()->getAnswerContents() as $answerContent) {
if ($answerContent->getField() == $field) {
$answers = [$answerRepository->findOneBy(['id' => $answerContent->getContent()])];
}
}
}
$answers[] = $mapObject->getAnswer();
$answers = array_merge($answers, $mapObject->getAnswers()->getValues());
} else {
$answers = [$mapObject->getAnswer()];
if ($mapObject->isIsIdInitial()) {
if (count($answerRepository->findViewAnswer($mapObject->getAnswer(), $this->getUser())) > 0) {
$field = $fieldRepository->findOneBy(['title' => "Id Initial", "form" => $mapObject->getAnswer()->getForm()]);
foreach ($mapObject->getAnswer()->getAnswerContents() as $answerContent) {
if ($answerContent->getField() == $field) {
$answers = [$answerRepository->findOneBy(['id' => $answerContent->getContent()])];
}
}
}
foreach ($mapObject->getAnswers() as $answer) {
if ($answer->getAuthor() == $this->getUser()) {
$answers[] = $answer;
} else {
if (count($answerRepository->findViewAnswer($answer, $this->getUser())) > 0) {
$answers[] = $answer;
}
}
}
}
}
return new JsonResponse(json_encode(['answers' => AnswerSerialization::serializeFeedAnswers($answers, $animalRepository, $this->getUser(), $lineRepository)], JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('/api-map-territories')]
public function getMapTerritories(Request $request): JsonResponse
{
if (!$this->getUser()) {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
} else {
$swLat = $request->query->get('swLat', false);
$swLng = $request->query->get('swLng', false);
$neLat = $request->query->get('neLat', false);
$neLng = $request->query->get('neLng', false);
$territories = $this->territoriesElastica($swLat, $swLng, $neLat, $neLng);
return new JsonResponse(json_encode($territories, JSON_THROW_ON_ERROR), 200, [], true);
}
}
#[Rest\Get('/api-territory-test')]
public function getTerritoryTest(Request $request, TerritoryRepository $territoryRepository): JsonResponse
{
if (!$this->getUser()) {
return new JsonResponse(json_encode('forbidden'), 403, [], true);
} else {
$territories = $territoryRepository->findAll();
foreach ($territories as $territory) {
if (!$territory->getShapes()->isEmpty()) {
dump($territory->getShapes()->getValues());
dd($territory);
} else {
dump($territory);
}
}
return new JsonResponse(json_encode(true, JSON_THROW_ON_ERROR), 200, [], true);
}
}
public function territoriesElastica(string|null $swLat = null, string|null $swLng = null, string|null $neLat = null, string|null $neLng = null): array
{
$query = new Query();
// Filtrer les territoires en fonction des coordonnées géographiques si fournies
if ($swLat && $swLng && $neLat && $neLng) {
$resultQuery = new BoolQuery();
// Construire la requête Elasticsearch
$posTerritoriesQuery = new BoolQuery();
$posTerritoriesQuery->addMust(new Range('geolocations.lat', [
'gte' => (float)$swLat,
'lte' => (float)$neLat
]));
$posTerritoriesQuery->addMust(new Range('geolocations.lng', [
'gte' => (float)$swLng,
'lte' => (float)$neLng
]));
$resultQuery->addMust($posTerritoriesQuery);
// Exécuter la requête Elasticsearch
$query->setQuery($resultQuery);
}
$results = $this->territoriesFinder->findRaw($query, 100000);
$territories = [];
foreach ($results as $territory) {
$territories[] = $territory->getSource();
}
return $territories;
}
#[Rest\Get('/api-pdf')]
public function testPdf(): void
{
$signature = $this->imageToBase64("https://sirene.tech/assets/upload/publication/signature-6616a89fd5954.png");
$html = $this->renderView('email/fdc77Agrainage/pdf.html.twig', [
'signature' => $signature
]);
$dompdf = new Dompdf();
$dompdf->loadHtml($html);
$dompdf->render();
$output = $dompdf->output();
$now = new \DateTime();
$filename = 'assets/' . $now->getTimestamp() . '.pdf';
file_put_contents($filename, $output);
}
private function imageToBase64($path): string
{
$type = pathinfo($path, PATHINFO_EXTENSION);
$data = file_get_contents($path);
return 'data:image/' . $type . ';base64,' . base64_encode($data);
}
#[Rest\Get('/api-clean-geoloc-object')]
public function getCleanGeolocObject(EntityManagerInterface $entityManager, MapObjectRepository $mapObjectRepository, GeolocationRepository $geolocationRepository): JsonResponse
{
//sql get geolocation with answer and mapObject
$conn = $entityManager->getConnection();
$sql = "SELECT DISTINCT a.geolocation_id,a.id as 'answer_id',m.id as 'map_object_id' FROM answer a INNER JOIN map_object m ON a.geolocation_id = m.geolocation_id;";
$stmt = $conn->prepare($sql);
$geoloc = $stmt->executeQuery();
foreach ($geoloc->fetchAllAssociative() as $geolocItem) {
$geoloc = $geolocationRepository->findOneBy(['id' => $geolocItem['geolocation_id']]);
$newGeoloc = new Geolocation();
$newGeoloc->setLat($geoloc->getLat());
$newGeoloc->setLng($geoloc->getLng());
$newGeoloc->setCity($geoloc->getCity());
$mapObject = $mapObjectRepository->findOneBy(['id' => $geolocItem['map_object_id']]);
$geolocationRepository->add($newGeoloc);
$mapObject->setGeolocation($newGeoloc);
$mapObjectRepository->save($mapObject);
}
$entityManager->flush();
return new JsonResponse(json_encode(true, JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('/api-clean-shape-object')]
public function getCleanShapeObject(EntityManagerInterface $entityManager, MapObjectRepository $mapObjectRepository, ShapeRepository $shapeRepository, ShapeHasPointRepository $shapeHasPointRepository): JsonResponse
{
//sql get shape with answer and mapObject
$conn = $entityManager->getConnection();
$sql = "SELECT DISTINCT a.shape_id,a.id as 'answer_id',m.id as 'map_object_id' FROM answer a INNER JOIN map_object m ON a.shape_id = m.shape_id;";
$stmt = $conn->prepare($sql);
$shape = $stmt->executeQuery();
foreach ($shape->fetchAllAssociative() as $shapeItem) {
$shape = $shapeRepository->findOneBy(['id' => $shapeItem['shape_id']]);
$newShape = new Shape();
$newShape->setType($shape->getType());
foreach ($shape->getShapeHasPoints() as $shapeHasPoint) {
$newShapeHasPoint = new ShapeHasPoint();
$newShapeHasPoint->setLat($shapeHasPoint->getLat());
$newShapeHasPoint->setLng($shapeHasPoint->getLng());
$shapeHasPointRepository->add($newShapeHasPoint);
$newShapeHasPoint->setShape($newShape);
}
$shapeRepository->add($newShape);
$mapObject = $mapObjectRepository->findOneBy(['id' => $shapeItem['map_object_id']]);
$mapObject->setShape($newShape);
$mapObjectRepository->save($mapObject);
$this->map_objectsPersister->replaceOne($mapObject);
}
$entityManager->flush();
return new JsonResponse(json_encode(true, JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('/api-clean-surface-fdc55')]
public function getCleanSurfaceFdc55(Fdc55Fence $fdc55Fence): JsonResponse
{
$fdc55Fence->cleanSurface();
return new JsonResponse(json_encode(true, JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('/api-clean-oprhelin-fdc55')]
public function getCleanOrphelinFdc55(Fdc55Fence $fdc55Fence): JsonResponse
{
$fdc55Fence->cleanOrphelinAnswer();
return new JsonResponse(json_encode(true, JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('/api-clean-shape-object-dev')]
public function getCleanShapeDev(MapObjectRepository $mapObjectRepository, ShapeRepository $shapeRepository, ShapeHasPointRepository $shapeHasPointRepository, EntityManagerInterface $entityManager): JsonResponse
{
$mapObjects = $mapObjectRepository->findAll();
foreach($mapObjects as $mapObject){
if($mapObject->getGeolocation()->getLat() == 0){
$mapObject->getGeolocation()->setLat($mapObject->getAnswer()->getGeolocation()->getLat());
$mapObject->getGeolocation()->setLng($mapObject->getAnswer()->getGeolocation()->getLng());
$mapObjectRepository->save($mapObject,true);
}
}
$this->map_objectsPersister->replaceMany($mapObjects);
return new JsonResponse(json_encode(true, JSON_THROW_ON_ERROR), 200, [], true);
}
#[Rest\Get('/api-test-mail-step-one')]
public function getTestMailStepOne(Request $request, Fdc77Agrainage $fdc77Agrainage, AnswerRepository $answerRepository): JsonResponse
{
$answer = $answerRepository->findOneBy(['id' => $request->query->get('id')]);
$fdc77Agrainage->mailStepOneValidationTest($answer);
return new JsonResponse(json_encode(true, JSON_THROW_ON_ERROR), 200, [], true);
}
}

src/Controller/ApiController.php line 2124