src/Controller/ApiV2/Residents/ProblemController.php line 100

  1. <?php
  3. namespace App\Controller\ApiV2\Residents;
  5. use App\Controller\ApiV2\AbstractController;
  6. use App\Entity\Task;
  7. use App\Entity\TaskType;
  8. use App\Enums\AttachmentTypeEnum;
  9. use App\Exception\FormException;
  10. use App\Form\ApiV2\BuildingProblemType;
  11. use App\Repository\BuildingRepository;
  12. use App\Repository\FlatRepository;
  13. use App\Repository\TaskFileRepository;
  14. use App\Repository\TaskRepository;
  15. use App\Repository\TaskTypeRepository;
  16. use App\Repository\UserRepository;
  17. use App\Security\Voter\FlatVoter;
  18. use App\Services\MailService;
  19. use App\Services\NotificationTokenService;
  20. use App\Services\TaskFileService;
  21. use App\Services\TaskService;
  22. use Doctrine\ORM\NonUniqueResultException;
  23. use Doctrine\ORM\NoResultException;
  24. use Exception;
  25. use FOS\RestBundle\Controller\Annotations as Rest;
  26. use GuzzleHttp\Exception\GuzzleException;
  27. use Symfony\Component\HttpFoundation\File\Exception\FileException;
  28. use Symfony\Component\HttpFoundation\File\UploadedFile;
  29. use Symfony\Component\HttpFoundation\Request;
  30. use Symfony\Component\HttpKernel\Exception\HttpException;
  31. use Symfony\Component\Mailer\Exception\TransportExceptionInterface;
  33. class ProblemController extends AbstractController
  34. {
  35. private FlatRepository $flatRepository;
  36. private TaskRepository $taskRepository;
  37. private TaskTypeRepository $taskTypeRepository;
  38. private TaskFileService $taskFileService;
  39. private TaskFileRepository $taskFileRepository;
  40. private TaskService $taskService;
  41. private NotificationTokenService $notificationTokenService;
  42. private UserRepository $userRepository;
  43. private MailService $mailService;
  44. private string $projectDir;
  46. /**
  47. * @param BuildingRepository $buildingRepository
  48. * @param UserRepository $userRepository
  49. * @param FlatRepository $flatRepository
  50. * @param TaskRepository $taskRepository
  51. * @param TaskTypeRepository $taskTypeRepository
  52. * @param TaskFileRepository $taskFileRepository
  53. * @param TaskFileService $taskFileService
  54. * @param TaskService $taskService
  55. * @param NotificationTokenService $notificationTokenService
  56. * @param MailService $mailService
  57. * @param string $projectDir
  58. */
  59. public function __construct(
  60. BuildingRepository $buildingRepository,
  61. UserRepository $userRepository,
  62. FlatRepository $flatRepository,
  63. TaskRepository $taskRepository,
  64. TaskTypeRepository $taskTypeRepository,
  65. TaskFileRepository $taskFileRepository,
  66. TaskFileService $taskFileService,
  67. TaskService $taskService,
  68. NotificationTokenService $notificationTokenService,
  69. MailService $mailService,
  70. string $projectDir
  71. ) {
  72. parent::__construct($buildingRepository);
  73. $this->flatRepository = $flatRepository;
  74. $this->taskRepository = $taskRepository;
  75. $this->taskTypeRepository = $taskTypeRepository;
  76. $this->taskFileService = $taskFileService;
  77. $this->taskFileRepository = $taskFileRepository;
  78. $this->taskService = $taskService;
  79. $this->notificationTokenService = $notificationTokenService;
  80. $this->userRepository = $userRepository;
  81. $this->mailService = $mailService;
  82. $this->projectDir = $projectDir;
  83. }
  85. /**
  86. * @param Request $request
  87. * @param int $id
  88. * @return array<string, mixed>
  89. * @throws NoResultException
  90. * @throws NonUniqueResultException
  91. */
  92. #[Rest\Get('/', name: 'residents_flats_problems_index')]
  93. public function index(Request $request, int $id): array
  94. {
  95. $flat = $this->flatRepository->find($id);
  97. if (!$flat) {
  98. $this->createNotFoundException();
  99. }
  101. $this->denyAccessUnlessGranted(FlatVoter::FLAT_BELONGS_TO_RESIDENT, $flat);
  103. $options = $this->getListOptions($request);
  104. $status = $request->get('status');
  106. $tasks = $this->taskRepository->findTasksByBuildingPaginated2(
  107. $flat->getBuilding(),
  108. $options,
  109. null,
  110. $status
  111. );
  113. $countTask = $this->taskRepository->countTasksByBuildingPaginated2(
  114. $flat->getBuilding(),
  115. $options,
  116. null,
  117. $status
  118. );
  120. return [
  121. 'data' => $tasks,
  122. 'count' => $countTask
  123. ];
  124. }
  126. /**
  127. * @param Request $request
  128. * @param int $id
  129. * @return array<mixed>
  130. * @throws Exception
  131. * @throws GuzzleException
  132. */
  133. #[Rest\Post('/', name: 'residents_flats_problems_store')]
  134. public function store(Request $request, int $id): array
  135. {
  136. $flat = $this->flatRepository->find($id);
  138. if (!$flat) {
  139. throw $this->createNotFoundException('Ovaj stan ne postoji.');
  140. }
  142. $this->denyAccessUnlessGranted(FlatVoter::FLAT_BELONGS_TO_RESIDENT, $flat);
  144. $building = $flat->getBuilding();
  145. $problemTypes = $this->taskTypeRepository->findAllTaskTypeIds();
  147. try {
  148. $problemData = $this->validateForm($request, BuildingProblemType::class, null, [
  149. 'types' => $problemTypes
  150. ]);
  152. $problemData['flatNumber'] = $flat->getDisplayFlatId();
  153. $problemData['email'] = $flat->getOwnerEmail();
  154. $problemData['phoneNumber'] = $flat->getOwnerContact();
  155. $problemData['resident'] = $this->getUser();
  157. $result = $this->taskService->saveTask(null, $building, $problemData);
  159. if (!($result instanceof Task)) {
  160. throw new HttpException($result['code'], $result['message']);
  161. }
  163. $this->notificationTokenService->sendPushNotificationAction($building, $problemData);
  165. $task = $result;
  167. /** @var array<UploadedFile> $uploadedTaskFiles */
  168. $uploadedTaskFiles = $request->files->get('file') ?? [];
  170. foreach ($uploadedTaskFiles as $uploadedTaskFile) {
  171. $originalFilename = pathinfo($uploadedTaskFile->getClientOriginalName(), PATHINFO_FILENAME);
  172. $safeFilename = transliterator_transliterate(
  173. 'Any-Latin; Latin-ASCII; [^A-Za-z0-9_] remove; Lower()',
  174. $originalFilename
  175. );
  176. $newFilename = sprintf("%s-%s.%s", $safeFilename, uniqid(), $uploadedTaskFile->guessClientExtension());
  178. try {
  179. $uploadedTaskFile->move(
  180. $this->getParameter('tasks_files_directory'),
  181. $newFilename
  182. );
  183. } catch (FileException $fileException) {
  184. }
  186. $taskFile = $this->taskFileService->createTaskFile($newFilename, $task);
  187. $task->addFile($taskFile);
  188. $this->taskFileRepository->save($taskFile);
  189. }
  191. return [
  192. 'data' => $task
  193. ];
  194. } catch (FormException $exception) {
  195. return $exception->getFormError();
  196. }
  197. }
  199. /**
  200. * @param Request $request
  201. * @param int $id
  202. * @return array<mixed>
  203. * @throws Exception
  204. * @throws GuzzleException|TransportExceptionInterface
  205. */
  206. #[Rest\Post('/v3', name: 'residents_flats_problems_store_new')]
  207. public function storeNew(Request $request, int $id): array
  208. {
  209. $flat = $this->flatRepository->find($id);
  211. if (!$flat) {
  212. throw $this->createNotFoundException('Ovaj stan ne postoji.');
  213. }
  215. $this->denyAccessUnlessGranted(FlatVoter::FLAT_BELONGS_TO_RESIDENT, $flat);
  217. $building = $flat->getBuilding();
  218. $problemTypes = $this->taskTypeRepository->findAllTaskTypeIds();
  220. try {
  221. $problemData = $this->validateForm($request, BuildingProblemType::class, null, [
  222. 'types' => $problemTypes
  223. ]);
  225. $problemData['flatNumber'] = $flat->getDisplayFlatId();
  226. $problemData['email'] = $flat->getOwnerEmail();
  227. $problemData['resident'] = $this->getUser();
  229. $result = $this->taskService->saveTask(null, $building, $problemData);
  231. if (!($result instanceof Task)) {
  232. throw new HttpException($result['code'], $result['message']);
  233. }
  235. $this->notificationTokenService->sendPushNotificationAction($building, $problemData);
  237. $task = $result;
  238. $user = $this->userRepository->findOneBy(['id' => $flat->getUser()->getId()]);
  240. /** @var UploadedFile|null $uploadedTaskFile */
  241. $uploadedTaskFile = $request->files->get('file') ?? [];
  242. $newFilename = null;
  243. $route = null;
  245. if (!empty($uploadedTaskFile)) {
  246. try {
  247. $originalFilename = pathinfo($uploadedTaskFile->getClientOriginalName(), PATHINFO_FILENAME);
  248. $safeFilename = transliterator_transliterate(
  249. 'Any-Latin; Latin-ASCII; [^A-Za-z0-9_] remove; Lower()',
  250. $originalFilename
  251. );
  252. $newFilename = sprintf(
  253. "%s-%s.%s",
  254. $safeFilename,
  255. uniqid(),
  256. $uploadedTaskFile->guessClientExtension()
  257. );
  259. list($w, $h) = getimagesize($uploadedTaskFile);
  260. $new_width = 735;
  261. $new_height = 1000;
  262. $dst = imagecreatetruecolor($new_width, $new_height);
  263. $src = imagecreatefromjpeg($uploadedTaskFile);
  264. imagecopyresampled($dst, $src, 0, 0, 0, 0, $new_width, $new_height, $w, $h);
  265. $path = sprintf("%s/src/uploads/residentProblems/%s", $this->projectDir, $building->getId());
  267. if (!is_dir($path)) {
  268. mkdir($path, 0777, true);
  269. }
  271. $path = sprintf("%s/%s", $path, $newFilename);
  272. imagejpeg($dst, $path);
  274. $route = sprintf(
  275. "%s%s/%s",
  276. $this->getParameter('tasks_files_directory'),
  277. $building->getId(),
  278. $newFilename
  279. );
  281. $taskFile = $this->taskFileService->createTaskFile($newFilename, $task);
  282. $task->addFile($taskFile);
  283. $this->taskFileRepository->save($taskFile);
  284. } catch (Exception $fileException) {
  285. throw new Exception($fileException->getMessage());
  286. }
  287. }
  289. $subject = 'Prijava problema';
  291. if ($user->getTaskNotificationEmail()) {
  292. $recipient = $user->getTaskNotificationEmail();
  293. } else {
  294. $mainUser = $user->getMainUser();
  295. if ($mainUser === null) {
  296. $recipient = $user->getEmail();
  297. } elseif ($mainUser->getTaskNotificationEmail()) {
  298. $recipient = $mainUser->getTaskNotificationEmail();
  299. } else {
  300. $recipient = $user->getEmail();
  301. }
  302. }
  304. $text = sprintf(
  305. "Poštovani,<br><br>Prijavljen problem za zgradu %s<br>Tip problema: %s<br>Opis problema: %s<br>
  306. Broj stana koji je prijavio problem: %s<br>Broj telefona stanara: %s<br><br>Srdačan pozdrav.",
  307. $building->getAddress(),
  308. $result->getTaskType()->getName(),
  309. $result->getDescription(),
  310. $result->getDisplayFlatId(),
  311. $result->getPhoneNumber()
  312. );
  314. $this->mailService->sendEmail(
  315. $subject,
  316. [$recipient],
  317. null,
  318. $text,
  319. [],
  320. $newFilename == null ? null : AttachmentTypeEnum::FROM_PATH->value,
  321. $route,
  322. $newFilename,
  323. null,
  324. true
  325. );
  327. return [
  328. 'data' => $task,
  329. 'code' => 200
  330. ];
  331. } catch (FormException $exception) {
  332. return $exception->getFormError();
  333. }
  334. }
  336. /**
  337. * @return array<TaskType>
  338. */
  339. #[Rest\Get('/types', name: 'residents_flats_problems_types')]
  340. public function getProblemTypes(): array
  341. {
  342. $types = $this->taskTypeRepository->findAll();
  344. return [
  345. 'data' => $types
  346. ];
  347. }
  349. /**
  350. * @param Request $request
  351. * @param int $id
  352. * @return array<string, mixed>
  353. * @throws NoResultException
  354. * @throws NonUniqueResultException
  355. */
  356. #[Rest\Get('/my', name: 'residents_flats_problems_my')]
  357. public function myTasks(Request $request, int $id): array
  358. {
  359. $flat = $this->flatRepository->find($id);
  361. if (!$flat) {
  362. $this->createNotFoundException();
  363. }
  365. $this->denyAccessUnlessGranted(FlatVoter::FLAT_BELONGS_TO_RESIDENT, $flat);
  367. $options = $this->getListOptions($request);
  368. $status = $request->get('status');
  370. $tasks = $this->taskRepository->findTasksByBuildingPaginated2(
  371. $flat->getBuilding(),
  372. $options,
  373. $flat->getDisplayFlatId(),
  374. $status
  375. );
  377. $countTask = $this->taskRepository->countTasksByBuildingPaginated2(
  378. $flat->getBuilding(),
  379. $options,
  380. $flat->getDisplayFlatId(),
  381. $status
  382. );
  384. return [
  385. 'data' => $tasks,
  386. 'count' => $countTask
  387. ];
  388. }
  389. }