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

  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. $status
  110. );
  112. $countTask = $this->taskRepository->countTasksByBuildingPaginated2(
  113. $flat->getBuilding(),
  114. $options,
  115. $status
  116. );
  118. return [
  119. 'data' => $tasks,
  120. 'count' => $countTask
  121. ];
  122. }
  124. /**
  125. * @param Request $request
  126. * @param int $id
  127. * @param int $scope
  128. * @return array<string, mixed>
  129. * @throws NoResultException
  130. * @throws NonUniqueResultException
  131. */
  132. #[Rest\Get('/{scope}', name: 'residents_flats_problems_scope', requirements: ['scope' => '\d+'])]
  133. public function getResidentsFlatProblemsWithScope(Request $request, int $id, int $scope): array
  134. {
  135. $flat = $this->flatRepository->find($id);
  137. if (!$flat) {
  138. $this->createNotFoundException();
  139. }
  141. $this->denyAccessUnlessGranted(FlatVoter::FLAT_BELONGS_TO_RESIDENT, $flat);
  143. $options = $this->getListOptions($request);
  144. $status = $request->get('status');
  146. $tasks = $this->taskRepository->findTasksByFlatPaginated(
  147. $flat,
  148. $options,
  149. $scope,
  150. $status
  151. );
  153. $countTask = $this->taskRepository->countTasksByFlatPaginated(
  154. $flat,
  155. $scope,
  156. $status
  157. );
  159. return [
  160. 'data' => $tasks,
  161. 'count' => $countTask
  162. ];
  163. }
  165. /**
  166. * @param Request $request
  167. * @param int $id
  168. * @return array<mixed>
  169. * @throws Exception
  170. * @throws GuzzleException
  171. */
  172. #[Rest\Post('/', name: 'residents_flats_problems_store')]
  173. public function store(Request $request, int $id): array
  174. {
  175. $flat = $this->flatRepository->find($id);
  177. if (!$flat) {
  178. throw $this->createNotFoundException('Ovaj stan ne postoji.');
  179. }
  181. $this->denyAccessUnlessGranted(FlatVoter::FLAT_BELONGS_TO_RESIDENT, $flat);
  183. $building = $flat->getBuilding();
  184. $problemTypes = $this->taskTypeRepository->findAllTaskTypeIds();
  186. try {
  187. $problemData = $this->validateForm($request, BuildingProblemType::class, null, [
  188. 'types' => $problemTypes
  189. ]);
  191. $problemData['flatNumber'] = $flat->getDisplayFlatId();
  192. $problemData['email'] = $flat->getOwnerEmail();
  193. $problemData['phoneNumber'] = $flat->getOwnerContact();
  194. $problemData['resident'] = $this->getUser();
  196. $result = $this->taskService->saveTask(null, $building, $problemData);
  198. if (!($result instanceof Task)) {
  199. throw new HttpException($result['code'], $result['message']);
  200. }
  202. $this->notificationTokenService->sendPushNotificationAction($building, $problemData);
  204. $task = $result;
  206. /** @var array<UploadedFile> $uploadedTaskFiles */
  207. $uploadedTaskFiles = $request->files->get('file') ?? [];
  209. foreach ($uploadedTaskFiles as $uploadedTaskFile) {
  210. $originalFilename = pathinfo($uploadedTaskFile->getClientOriginalName(), PATHINFO_FILENAME);
  211. $safeFilename = transliterator_transliterate(
  212. 'Any-Latin; Latin-ASCII; [^A-Za-z0-9_] remove; Lower()',
  213. $originalFilename
  214. );
  215. $newFilename = sprintf("%s-%s.%s", $safeFilename, uniqid(), $uploadedTaskFile->guessClientExtension());
  217. try {
  218. $uploadedTaskFile->move(
  219. $this->getParameter('tasks_files_directory'),
  220. $newFilename
  221. );
  222. } catch (FileException $fileException) {
  223. }
  225. $taskFile = $this->taskFileService->createTaskFile($newFilename, $task);
  226. $task->addFile($taskFile);
  227. $this->taskFileRepository->save($taskFile);
  228. }
  230. return [
  231. 'data' => $task
  232. ];
  233. } catch (FormException $exception) {
  234. return $exception->getFormError();
  235. }
  236. }
  238. /**
  239. * @param Request $request
  240. * @param int $id
  241. * @return array<mixed>
  242. * @throws Exception
  243. * @throws GuzzleException|TransportExceptionInterface
  244. */
  245. #[Rest\Post('/v3', name: 'residents_flats_problems_store_new')]
  246. public function storeNew(Request $request, int $id): array
  247. {
  248. $flat = $this->flatRepository->find($id);
  250. if (!$flat) {
  251. throw $this->createNotFoundException('Ovaj stan ne postoji.');
  252. }
  254. $this->denyAccessUnlessGranted(FlatVoter::FLAT_BELONGS_TO_RESIDENT, $flat);
  256. $building = $flat->getBuilding();
  257. $problemTypes = $this->taskTypeRepository->findAllTaskTypeIds();
  259. try {
  260. $problemData = $this->validateForm($request, BuildingProblemType::class, null, [
  261. 'types' => $problemTypes
  262. ]);
  264. $problemData['flatNumber'] = $flat->getDisplayFlatId();
  265. $problemData['email'] = $flat->getOwnerEmail();
  266. $problemData['resident'] = $this->getUser();
  268. $result = $this->taskService->saveTask(null, $building, $problemData);
  270. if (!($result instanceof Task)) {
  271. throw new HttpException($result['code'], $result['message']);
  272. }
  274. $this->notificationTokenService->sendPushNotificationAction($building, $problemData);
  276. $task = $result;
  277. $user = $this->userRepository->findOneBy(['id' => $flat->getUser()->getId()]);
  279. /** @var UploadedFile|null $uploadedTaskFile */
  280. $uploadedTaskFile = $request->files->get('file') ?? [];
  281. $newFilename = null;
  282. $route = null;
  284. if (!empty($uploadedTaskFile)) {
  285. try {
  286. $originalFilename = pathinfo($uploadedTaskFile->getClientOriginalName(), PATHINFO_FILENAME);
  287. $safeFilename = transliterator_transliterate(
  288. 'Any-Latin; Latin-ASCII; [^A-Za-z0-9_] remove; Lower()',
  289. $originalFilename
  290. );
  291. $newFilename = sprintf(
  292. "%s-%s.%s",
  293. $safeFilename,
  294. uniqid(),
  295. $uploadedTaskFile->guessClientExtension()
  296. );
  298. list($w, $h) = getimagesize($uploadedTaskFile);
  299. $new_width = 735;
  300. $new_height = 1000;
  301. $dst = imagecreatetruecolor($new_width, $new_height);
  302. $src = imagecreatefromjpeg($uploadedTaskFile);
  303. imagecopyresampled($dst, $src, 0, 0, 0, 0, $new_width, $new_height, $w, $h);
  304. $path = sprintf("%s/src/uploads/residentProblems/%s", $this->projectDir, $building->getId());
  306. if (!is_dir($path)) {
  307. mkdir($path, 0777, true);
  308. }
  310. $path = sprintf("%s/%s", $path, $newFilename);
  311. imagejpeg($dst, $path);
  313. $route = sprintf(
  314. "%s%s/%s",
  315. $this->getParameter('tasks_files_directory'),
  316. $building->getId(),
  317. $newFilename
  318. );
  320. $taskFile = $this->taskFileService->createTaskFile($newFilename, $task);
  321. $task->addFile($taskFile);
  322. $this->taskFileRepository->save($taskFile);
  323. } catch (Exception $fileException) {
  324. throw new Exception($fileException->getMessage());
  325. }
  326. }
  328. $subject = 'Prijava problema';
  329. if ($user->getTaskNotificationEmail()) {
  330. $recipient = $user->getTaskNotificationEmail();
  331. } else {
  332. $mainUser = $user->getMainUser();
  333. if ($mainUser === null) {
  334. $recipient = $user->getEmail();
  335. } elseif ($mainUser->getTaskNotificationEmail()) {
  336. $recipient = $mainUser->getTaskNotificationEmail();
  337. } else {
  338. $recipient = $user->getEmail();
  339. }
  340. }
  342. $text = sprintf(
  343. "Poštovani,<br><br>Prijavljen problem za zgradu %s<br>Tip problema: %s<br>Opis problema: %s<br>
  344. Broj stana koji je prijavio problem: %s<br>Broj telefona stanara: %s<br><br>Srdačan pozdrav.",
  345. $building->getAddress(),
  346. $result->getTaskType()->getName(),
  347. $result->getDescription(),
  348. $result->getDisplayFlatId(),
  349. $result->getPhoneNumber()
  350. );
  352. $this->mailService->sendEmail(
  353. $subject,
  354. [$recipient],
  355. null,
  356. $text,
  357. [],
  358. $newFilename == null ? null : AttachmentTypeEnum::FROM_PATH->value,
  359. $route,
  360. $newFilename,
  361. null,
  362. true
  363. );
  365. return [
  366. 'data' => $task,
  367. 'code' => 200
  368. ];
  369. } catch (FormException $exception) {
  370. return $exception->getFormError();
  371. }
  372. }
  374. /**
  375. * @return array<TaskType>
  376. */
  377. #[Rest\Get('/types', name: 'residents_flats_problems_types')]
  378. public function getProblemTypes(): array
  379. {
  380. $types = $this->taskTypeRepository->findAll();
  382. return [
  383. 'data' => $types
  384. ];
  385. }
  386. }