src/Globals/ClaimManagementBundle/Controller/ClaimFlowCrudController.php line 581

Open in your IDE?
  1. <?php
  3. namespace Globals\ClaimManagementBundle\Controller;
  5. use Doctrine\ORM\EntityManager;
  6. use Globals\ClaimManagementBundle\DependencyInjection\CompareHelpers\DisbursementCompareHelper;
  7. use Globals\ClaimManagementBundle\DependencyInjection\ExpensesHelper;
  8. use Globals\ClaimManagementBundle\Entity\Claim;
  9. use Globals\ClaimManagementBundle\Entity\ClaimNoteMedia;
  10. use Globals\ClaimManagementBundle\Entity\DiaryEntry;
  11. use Globals\ClaimManagementBundle\Entity\DiaryOtherResource;
  12. use Globals\ClaimManagementBundle\Event\ClaimDiaryAssignedEvent;
  13. use Globals\ClaimManagementBundle\Event\ClaimDiaryCompleteEvent;
  14. use Globals\ClaimManagementBundle\Form\Coverage;
  15. use Globals\ClaimManagementBundle\Form\Deductible;
  16. use Globals\ClaimManagementBundle\Form\DiaryFormType;
  17. use Globals\ClaimManagementBundle\Form\DisbursementTimeLogType;
  18. use Globals\CoreBundle\Helpers\MailHelper;
  19. use Globals\CustomerManagementBundle\DependencyInjection\DisbursementHelper;
  20. use Globals\MailManagementBundle\Entity\Mail;
  21. use Globals\MailManagementBundle\Entity\MailRecipient;
  22. use Globals\ResourceManagementBundle\Entity\Resource;
  23. use Globals\ResourceManagementBundle\Service\SLogger;
  24. use Sensio\Bundle\FrameworkExtraBundle\Configuration\Method;
  25. use Sensio\Bundle\FrameworkExtraBundle\Configuration\ParamConverter;
  26. use Symfony\Bundle\FrameworkBundle\Controller\Controller;
  27. use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;
  28. use Symfony\Component\Finder\Finder;
  29. use Symfony\Component\Form\Form;
  30. use Symfony\Component\HttpFoundation\File\UploadedFile;
  31. use Symfony\Component\HttpFoundation\JsonResponse;
  32. use Symfony\Component\HttpFoundation\Request;
  33. use Globals\ClaimManagementBundle\Entity\Coverage as CoverageEntity;
  34. use Symfony\Component\HttpFoundation\Response;
  35. use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
  36. use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
  37. use Globals\InvoiceManagementBundle\Entity\Disbursement;
  38. use Globals\ClaimManagementBundle\Event\ClaimDuplicatedEvent;
  39. use DateTime;
  42. /**
  43.  * @Route("/administration/claims/api")
  44.  */
  45. class ClaimFlowCrudController extends Controller
  46. {
  47.     
  48.     /**
  49.      * @Route("/clone/{id}")
  50.      * @Method("POST")
  51.      * @ParamConverter("claim", class="ClaimManagementBundle:Claim")
  52.      */
  53.     public function cloneExistingClaim(Claim $claim)
  54.     {
  55.         if($claim){
  57.         }else{
  58.             throw new NotFoundHttpException("Couldn't find this claim!");
  59.         }
  60.     }
  62.     /**
  63.      * @Route("/update/{id}")
  64.      * @ParamConverter("claim", class="ClaimManagementBundle:Claim")
  65.      */
  66.     public function updateClaimFlowAction(Claim $claim)
  67.     {
  68.         /** @var Claim $claim */
  69.         return new JsonResponse(['claim_number'=>$claim->getClaimNumber()]);
  70.     }
  72.     /**
  73.      * @Route("/create/deductible")
  74.      */
  75.     public function createDeductibleAction(Request $request)
  76.     {
  77.         # 1) If we are POST-ing *only*
  78.         if($request->getMethod() == "POST"){
  80.             $deductibleData = $request->request->get('newDeductible');
  82.             $deductibleData['name'] = 'Deductible';
  83.             
  84.             $form = $this->createForm(Deductible::class, new \Globals\ClaimManagementBundle\Entity\Deductible());
  86.             $form->submit($deductibleData);
  88.             if($form->isValid()){
  89.                 $newDeductible = $form->getData();
  90.                 $em = $this->getDoctrine()->getManager();
  91.                 $em->persist($newDeductible);
  92.                 $em->flush();
  94.                 # Add Claim Note that Deductible was added
  95.                 $ClaimNote = $this->container->get("claim.note_provider");
  96.                 //Status note = 68 Claim Deductible
  97.                 $ClaimNote->addClaimNote($newDeductible->getClaim(), "Claim Deductible was added.", false, 68);
  99.                 return new JsonResponse(['error'=>false]);
  100.             }else{
  101.                 $errors = [];
  102.                 foreach($form as $formField){
  103.                     if((string)$formField->getErrors(true)){
  104.                         $errors[] = [
  105.                             'id'=>$formField->getName(),
  106.                             'text'=>(string)$formField->getErrors(true)
  107.                         ];
  108.                     }
  109.                 }
  110.                 return new JsonResponse(['error'=>true, 'data' => ['errors' => $errors]]);
  111.             }
  113.         }else{
  114.             return new JsonResponse(['error'=>true]);
  115.         }
  116.     }
  118.     /**
  119.      * @Route("/create/coverage")
  120.      */
  121.     public function createCoverageAction(Request $request)
  122.     {
  123.         # 1) If we are POST-ing *only*
  124.         if($request->getMethod() == "POST"){
  125.             
  126.             $coverageData = $request->request->get('newCoverage');
  127.             
  128.             $form = $this->createForm(Coverage::class, new CoverageEntity());
  130.             $form->submit($coverageData);
  132.             if($form->isValid()){
  133.                 $newCoverage = $form->getData();
  134.                 $em = $this->getDoctrine()->getManager();
  135.                 $em->persist($newCoverage);
  136.                 $em->flush();
  137.                 return new JsonResponse(['error'=>false]);
  138.             }else{
  139.                 $errors = [];
  140.                 foreach($form as $formField){
  141.                     if((string)$formField->getErrors(true)){
  142.                         $errors[] = [
  143.                             'id'=>$formField->getName(),
  144.                             'text'=>(string)$formField->getErrors(true)
  145.                         ];
  146.                     }
  147.                 }
  148.                 return new JsonResponse(['error'=>true, 'data' => ['errors' => $errors]]);
  149.             }
  150.         }else{
  151.             return new JsonResponse(['error'=>true]);
  152.         }
  153.     }
  157.     /**
  158.      * @Route("/update/set-inspection-date/{id}")
  159.      * @ParamConverter("claim", class="ClaimManagementBundle:Claim")
  160.      */
  161.     public function setInspectionDate(Claim $claim, Request $request)
  162.     {
  163.         # logged in user
  164.         $user = $this->get('security.token_storage')->getToken()->getUser();
  166.         $response = ['error'=>false, 'data'=>[]];
  167.         if($claim){
  168.             $incoming_date = $request->request->get('date');
  169.             $incoming_time = $request->request->get('time');
  170.             $incoming_note = $request->request->get('note');
  171.             $needs_inspection = $request->request->get('needs_inspection');
  172.             $needs_inspection = $needs_inspection == 0 ? false:true;
  173.             # combine date and time
  174.             $Date = new \DateTime($incoming_date);
  175.             if(($needs_inspection) && (empty($incoming_time) || is_null($incoming_time) || $incoming_time == '00:00 AM'))
  176.             {
  177.                 $response = ['error'=>true, 'data'=>['message'=>'Time inspected is missing.']];
  178.                 return new JsonResponse($response);
  179.             }
  181.             if ($needs_inspection){
  182.                 $Time = DateTime::createFromFormat('Y-m-d H:i A',$Date->format('Y-m-d')." ".$incoming_time); //new \DateTime($incoming_time);
  183.                 $mergeDateTime = $Time->format( 'Y-m-d H:i' );
  184.             } else {
  185.                 $mergeDateTime = "";
  186.             }
  188.             $claim->setNeedsInspection($needs_inspection);
  189.             $em = $this->getDoctrine()->getManager();
  190.             $em->persist($claim);
  191.             $em->flush();
  193.             if( $this->get('claim.status_update')->setInspectionDate( $claim, $mergeDateTime, $incoming_note ) ){
  194.                 # create our note
  195.                 $inspectionDate = new DateTime($incoming_date);
  196.                 $inspectionNote = "" . $user->getUsername() . sprintf(" has inspected the claim: %s, note: %s", $inspectionDate->format('m/d/Y h:i A'), $incoming_note);
  198.                 if ($claim->getTransactionId() && $claim->getTransactionId() != "") {
  199.                     # send our xml to xact
  200.                     $xactService = $this->get('integration.xact.outbound');
  201.                     $xactService->exportAddNotes(
  202.                         [
  203.                             'transactionId' => $claim->getTransactionId(),
  204.                             'userName' => $user->getFullName(),
  205.                             'dateTime' => $inspectionDate->getTimeStamp(),
  206.                             'noteType' => 'Inspected',
  207.                             'notes' => $inspectionNote
  208.                         ]
  209.                     );
  210.                 }
  212.                 if($claim->getAssignmentId()){
  213.                     $symService = $this->get('integration.symbility.outbound');
  214.                     $symService->pushInspectionDate($inspectionDate->format('m/d/Y'), $claim->getClaimNumber(), $claim->getAssignmentId());
  215.                 }
  217.             } else {
  218.                 $response = ['error'=>true, 'data'=>['message'=>'Could not set inspection date. Please try again.']];
  220.             }
  222.             return new JsonResponse($response);
  223.         }else{
  224.             throw new NotFoundHttpException("Couldn't find this claim!");
  225.         }
  226.     }
  228.     /**
  229.      * @Route("/update/set-planned-inspection-date/{id}")
  230.      * @ParamConverter("claim", class="ClaimManagementBundle:Claim")
  231.      */
  232.     public function setPlannedInspectionDate(Claim $claim, Request $request)
  233.     {
  235.         # logged in user
  236.         $user = $this->get('security.token_storage')->getToken()->getUser();
  238.         $response = ['error'=>false, 'data'=>[]];
  239.         if($claim){
  240.             $incoming_date = $request->request->get('date');
  241.             $incoming_time = $request->request->get('time');
  244.             // Ensure $incoming_date is a valid date string before creating DateTime object
  245.             $Date = new \DateTime($incoming_date);
  246.             // Format the DateTime object to string
  247.             $formattedDate = $Date->format('Y-m-d');
  248.             // Combine the formatted date string with the incoming time and convert it to a timestamp
  249.             $combinedDT = date('Y-m-d H:i', strtotime("$formattedDate $incoming_time"));
  251.             $dt = new \DateTime($combinedDT);
  252.             $claim->setPlannedInspectionDate($dt);
  254.             $em = $this->getDoctrine()->getManager();
  255.             $em->persist($claim);
  256.             $em->flush();
  258.             $ClaimNote = $this->container->get("claim.note_provider");
  259.             //Status note = 69 Claim Disbursement
  260.             $ClaimNote->addClaimNote($claim, "Planned Inspection date has been changed to " .$incoming_date, false, 69);
  262.             return new JsonResponse($response);
  263.         }else{
  264.             throw new NotFoundHttpException("Couldn't find this claim!");
  265.         }
  266.     }
  268.     /**
  269.      * @Route("/update/set-first-contact-date/{id}")
  270.      * @ParamConverter("claim", class="ClaimManagementBundle:Claim")
  271.      */
  272.     public function setFirstContactDate(Claim $claim, Request $request)
  273.     {
  274.         # logged in user
  275.         $user = $this->get('security.token_storage')->getToken()->getUser();
  277.         $response = ['error'=>false, 'data'=>[]];
  279.         if($claim){
  280.             $incoming_date = $request->request->get('date');
  281.             $incoming_time = $request->request->get('time');
  282.             $incoming_note = $request->request->get('note');
  284.             # combine date and time
  285.             $Date = new \DateTime($incoming_date);
  286.             $Time = new \DateTime($incoming_time);
  287.             $mergeDateTime = $Date->format('Y-m-d') . ' ' . $Time->format('H:i:s');
  289.             # create our note
  290.             $contactDate = new DateTime($incoming_date);
  291.             $contactDateTime = new \DateTime($mergeDateTime);
  293.             if( $contactDateTime < $claim->getDateReceived()){
  294.                 $response['error'] = true;
  295.                 $response['data']['errors'][] = 'Date contacted cannot be before date received!';
  296.                 return new JsonResponse($response);
  297.             }
  298.             $contactNote = "" . $user->getUsername() . sprintf(" has made  First Contact: %s, note: %s", $contactDate->format('m/d/Y'), $incoming_note);
  299.             if($incoming_date){
  300.                 $note = "";
  301.                 if($incoming_note){
  302.                     $note = $incoming_note;
  303.                 }
  304.                 # export to xact to let them know first contact has been made
  305.                 if( $this->get('claim.status_update')->setFirstContactDate($claim, $mergeDateTime, $note) ){
  306.                     # If Xact claim, lets do export
  307.                     if ($claim->getTransactionId()) {
  308.                         $xactService = $this->get('integration.xact.outbound');
  309.                         $xactService->exportAddNotes(
  310.                             [
  311.                                 'transactionId' => $claim->getTransactionId(),
  312.                                 'userName' => $user->getFullName(),
  313.                                 'dateTime' => $contactDate->getTimeStamp(),
  314.                                 'noteType' => 'Contacted',
  315.                                 'notes' => $contactNote
  316.                             ]
  317.                         );
  319.                     }
  320.                     if($claim->getAssignmentId()){
  321.                         // commented as we not need to send first contact dateto symbility
  322.                       //  $symService = $this->get('integration.symbility.outbound');
  323.                        // $symService->pushFirstContactDate($contactDate->format('m/d/Y'.' '. $Time->format('H:i:s')), $claim->getClaimNumber(), $claim->getAssignmentId());
  324.                     }
  325.                 } else {
  326.                     $response['error'] = true;
  327.                     $response['data']['errors'][] = 'The date cannot be set in the future!';
  328.                 }
  329.             }else{
  330.                 $response['error'] = true;
  331.                 $response['data']['errors'][] = 'You are missing the date!';
  332.             }
  333.             return new JsonResponse($response);
  334.         }else{
  335.             throw new NotFoundHttpException("Couldn't find this claim!");
  336.         }
  337.     }
  339.     /**
  340.      * @Route("/update/set-review-date/{id}")
  341.      * @ParamConverter("claim", class="ClaimManagementBundle:Claim")
  342.      */
  343.     public function setReadyForReviewDate(Claim $claim, Request $request)
  344.     {
  345.         $response = ['error'=>false, 'data'=>[]];
  346.         if($claim){
  347.             $em = $this->getDoctrine()->getManager();
  348.             $currentDate = new \DateTime();
  349.             $result = $this->get('claim.status_update')->setReadyForReviewDate($claim, $currentDate->format("m/d/Y h:i A"));
  351.             if($result) {
  352.                 $slog = new SLogger();
  353.                 $claim->setReportPDFStacking(1);
  354.                 $em->persist($claim);
  355.                 $em->flush();
  357.                 $slog->log($claim->getReportPDFStacking());
  359.                 if($claim->getAssignmentId()){
  360.                     $symService = $this->get('integration.symbility.outbound');
  361.                     $symService->pushReadyForReview($claim->getClaimNumber(), $claim->getAssignmentId());
  362.                 }
  363.             }
  364.             return new JsonResponse($response);
  365.         }else{
  366.             throw new NotFoundHttpException("Couldn't find this claim!");
  367.         }
  368.     }
  370.     /**
  371.      * @Route("/update/undo-ready-review/{id}")
  372.      * @ParamConverter("claim", class="ClaimManagementBundle:Claim")
  373.      */
  374.     public function setUndoReadyReview(Claim $claim, Request $request)
  375.     {
  376.         $response = ['error'=>false, 'data'=>[]];
  377.         if($claim){
  378.             $this->get('claim.status_update')->undoReadyForReview($claim);
  380.             if($claim->getIsLocked()){
  381.                 $this->get('claim.status_update')->unlockClaim($claim);
  382.             }
  383.             return new JsonResponse($response);
  384.         }else{
  385.             throw new NotFoundHttpException("Couldn't find this claim!");
  386.         }
  387.     }
  389.     /**
  390.      * @Route("/update/reopen-claim/{id}")
  391.      * @ParamConverter("claim", class="ClaimManagementBundle:Claim")
  392.      */
  393.     public function reopenClaim(Claim $claim, Request $request)
  394.     {
  395.         $reason = $request->request->get("reason");
  396.         $settlement_type_reopen = $request->request->get("settlement_type_reopen");
  397.         $cwop_reason_reopen = $request->request->get("cwop_reason_reopen");
  398.         $denial_description_line_reopen = $request->request->get("denial_description_line_reopen");
  399.         $response = ['error'=>false, 'data'=>[]];
  400.         $strCWOPReason ='';
  401.         if($claim){
  402.             $this->get('claim.status_update')->reopenClaim($claim, $reason);
  403.             if (!empty($claim->getCustomer()->isTpaUi())) {
  404.                 $em = $this->container->get("doctrine.orm.entity_manager");
  405.                 if (!empty($cwop_reason_reopen)) {
  406.                     $objCwopReason = $em->getRepository("ClaimManagementBundle:CwopReason")->findOneBy(['id' => $cwop_reason_reopen]);
  408.                     if (!empty($objCwopReason)) {
  409.                         $claim->setReopenCwopRsn($objCwopReason);
  410.                         $claim->setReopenDenialDescriptionLine($denial_description_line_reopen);
  411.                         $strCWOPReason = $objCwopReason->getDescription();
  412.                     }
  413.                 }
  414.                 $objSettlementType = $em->getRepository("ClaimManagementBundle:SettlementType")->find($settlement_type_reopen);
  415.                 if (!empty($objSettlementType)) {
  416.                     $claim->setReopenSettlementType($objSettlementType);
  417.                 }
  418.                 $em->persist($claim);
  419.                 $em->flush();
  420.                 $ClaimNote = $this->container->get("claim.note_provider");
  421.                 if(!empty($strCWOPReason)){
  422.                     $ClaimNote->addClaimNote($claim, "Reopen CWOP Reason ($strCWOPReason) added to the claim with Denial Description as ($denial_description_line_reopen).", false);
  423.                 }
  424.             }
  425.             return new JsonResponse($response);
  426.         }else{
  427.             throw new NotFoundHttpException("Couldn't find this claim!");
  428.         }
  429.     }
  431.     /**
  432.      * @Route("/update/reinspect-claim/{id}")
  433.      * @ParamConverter("claim", class="ClaimManagementBundle:Claim")
  434.      */
  435.     public function reInspectClaim(Claim $claim, Request $request)
  436.     {
  437.         $reason = $request->request->get("reason");
  438.         $response = ['error'=>false, 'data'=>[]];
  439.         if($claim){
  440.             $this->get('claim.status_update')->reInspectClaim($claim, $reason);
  441.             return new JsonResponse($response);
  442.         }else{
  443.             throw new NotFoundHttpException("Couldn't find this claim!");
  444.         }
  445.     }
  447.     /**
  448.      * @Route("/update/set-in-progress/{id}")
  449.      * @ParamConverter("claim", class="ClaimManagementBundle:Claim")
  450.      */
  451.     public function setInProgress(Claim $claim, Request $request)
  452.     {
  453.         $response = ['error'=>false, 'data'=>[]];
  454.         if($claim){
  455.             $this->get('claim.status_update')->setInProgress($claim);
  456.             return new JsonResponse($response);
  457.         }else{
  458.             throw new NotFoundHttpException("Couldn't find this claim!");
  459.         }
  460.     }
  463.     /**
  464.      * @Route("/create/claim-note/{id}")
  465.      * @ParamConverter("claim", class="ClaimManagementBundle:Claim")
  466.      */
  467.     public function addClaimNote(Claim $claim, Request $request)
  468.     {
  469.         # logged in user
  470.         $user = $this->get('security.token_storage')->getToken()->getUser();
  472.         $response = ['error'=>false, 'data'=>[]];
  474.         $comment = $request->request->get('comment');
  475.         $outbound = $request->request->get('outbound');
  476.         $send = false;
  477.         if( $outbound != "" ){
  478.             $send = $outbound == 1;
  479.         }
  481.         # Check for post #
  482.         if ($comment) {
  483.             if ($claim) {
  485.                 /**
  486.                  * @var $file UploadedFile
  487.                  */
  488.                 $file = $request->files->all()['media'] ?? null;
  489.                 $claimNoteMediaService = $this->get('claim_note.media');
  490.                 $newFilename = uniqid();
  491.                 if ($file instanceof UploadedFile) {
  492.                     $mediaValid = $claimNoteMediaService->validateClaimNoteMedia($file);
  493.                     if ($mediaValid['error']) {
  494.                         return new JsonResponse(['error' => $mediaValid['message']]);
  495.                     }
  496.                     $copyMedia = $claimNoteMediaService->copyClaimNoteMedia($file, $newFilename, $claim->getId());
  497.                     if ($copyMedia !== true) {
  498.                         return new JsonResponse(['error' => (is_bool($copyMedia) ? "Failed to copy the uploaded media" : $copyMedia)]);
  499.                     }
  500.                 }
  502.                 $em = $this->getDoctrine()->getManager();
  503.                 $claimNote = $this->get('claim.note_provider')->addClaimNote($claim, $comment);
  504.                 $em->refresh($claimNote);
  506.                 if ($file instanceof UploadedFile) {
  507.                     try {
  508.                         $em->getRepository(ClaimNoteMedia::class)->createClaimNoteMedia(
  509.                             $claim->getId(),
  510.                             $claimNote->getId(),
  511.                             $file->getClientOriginalExtension(),
  512.                             $file->getClientOriginalName(),
  513.                             sprintf("%s.%s", $newFilename, $file->getClientOriginalExtension()),
  514.                             $file->getClientMimeType()
  515.                         );
  516.                     } catch (\Exception $exception) {
  517.                         $em->remove($claimNote);
  518.                         return new JsonResponse([
  519.                             'error' => sprintf("Failed to store ClaimNoteMedia Error: %s", $exception->getMessage())
  520.                         ]);
  521.                     }
  522.                 }
  524.                 # log note to xact
  525.                 if($send && $claim->getTransactionId()){
  526.                     $xactService = $this->get('integration.xact.outbound');
  527.                     $xactService->exportAddNotes(
  528.                         [
  529.                             'transactionId' => $claim->getTransactionId(),
  530.                             'userName' => $user->getFullName(),
  531.                             'dateTime' => time(),
  532.                             'notes' => $comment
  534.                         ]
  535.                     );
  536.                 }
  538.                 if($send && $claim->getAssignmentId()){
  539.                     $symService = $this->get('integration.symbility.outbound');
  540.                     $symService->addNotes(
  541.                         [
  542.                             'transactionId' => $claim->getClaimNumber(),
  543.                             'userName' => $user->getFullName(),
  544.                             'dateTime' => time(),
  545.                             'assignmentID' =>$claim->getAssignmentId(),
  546.                             'notes' => $comment
  547.                         ]
  548.                     );
  549.                 }
  550.                 
  551.                 return new JsonResponse($response);
  553.             } else {
  554.                 throw new NotFoundHttpException("Couldn't find this claim!");
  555.             }
  556.         }else{
  557.             return new JsonResponse(['error' => 'File Note\'s Cannot Be Blank']);
  558.         }
  559.     }
  561.     /**
  562.      * @Route("/update/lock/{id}")
  563.      * @ParamConverter("claim", class="ClaimManagementBundle:Claim")
  564.      */
  565.     public function lockClaim(Claim $claim)
  566.     {
  567.         $this->get('claim.assignment')->assignCurrentUserAsExaminer($claim);
  568.         $this->get('claim.status_update')->lockClaim($claim);
  569.         return new JsonResponse(['error'=>false]);
  570.     }
  572.     /**
  573.      * @Route("/update/unlock/{id}")
  574.      * @ParamConverter("claim", class="ClaimManagementBundle:Claim")
  575.      */
  576.     public function unlockClaim(Claim $claim)
  577.     {
  578.         $this->get('claim.status_update')->unlockClaim($claim);
  579.         return new JsonResponse(['error'=>false]);
  580.     }
  582.     /**
  583.      * @Route("/update/in-progress/{id}")
  584.      * @ParamConverter("claim", class="ClaimManagementBundle:Claim")
  585.      */
  586.     public function markInExaminerProgress(Claim $claim)
  587.     {
  588.         $this->get('claim.status_update')->markInProgressExaminer($claim);
  589.         return new JsonResponse(['error'=>false]);
  590.     }
  592.     /**
  593.      * @Route("/update/claim-status/{id}")
  594.      * @ParamConverter("claim", class="ClaimManagementBundle:Claim")
  595.      */
  596.     public function updateClaimStatus(Claim $claim, Request $request)
  597.     {
  598.         $status_id = $request->request->get('status_id');
  599.         if($status_id==97){
  600.             $status_id=30;
  601.             $em = $this->container->get("doctrine.orm.entity_manager");
  602.             $stmt = $em->getConnection()->prepare("UPDATE claim SET date_closed = NOW(), updated_at = NOW() WHERE id = ? ");
  603.             $stmt->execute([$claim->getId()]);
  604.         }//Claim Tech closing
  605.         $this->get('claim.status_update')->changeStatus($claim,$status_id);
  606.         return new JsonResponse(['error'=>false]);
  607.     }
  609.     /**
  610.      * @Route("/update/examiner-hold/{id}")
  611.      * @ParamConverter("claim", class="ClaimManagementBundle:Claim")
  612.      */
  613.     public function markInExaminerHold(Claim $claim)
  614.     {
  615.         $this->get('claim.status_update')->markInHoldExaminer($claim);
  616.         return new JsonResponse(['error'=>false]);
  617.     }
  619.     /**
  620.      * @Route("/update/qa-approved/{id}")
  621.      * @ParamConverter("claim", class="ClaimManagementBundle:Claim")
  622.      */
  623.     public function markQaApproved($claim)
  624.     {
  625.         $resource = $this->get('security.token_storage')->getToken()->getUser();
  626.         $currentDate = new \DateTime();
  628.         $this->get('claim.status_update')->markQaApproved( $claim, $resource, $currentDate->format("m/d/Y h:i A") );
  630.         return new JsonResponse(['error'=>false]);
  631.     }
  633.     /**
  634.      * @Route("/update/qa-rejected/{id}")
  635.      * @ParamConverter("claim", class="ClaimManagementBundle:Claim")
  636.      */
  637.     public function markQaRejected($claim, Request $request)
  638.     {
  639.         $resource = $this->get('security.token_storage')->getToken()->getUser();
  640.         $reason = $request->request->get('reason');
  641.         $reasonCodeIds = $request->request->get('reason_code');
  643.         $ReasonCodeIds = array();
  644.         if (strpos($reasonCodeIds, ',') !== false) {
  645.             $ReasonCodeIds = explode(",", $reasonCodeIds);
  646.         }else{
  647.             $ReasonCodeIds[0]= $reasonCodeIds;
  648.         }
  649.         $em = $this->getDoctrine()->getManager();
  650.         $currentDate = new \DateTime();
  651.         $ClaimReportRepo = $em->getRepository("ClaimManagementBundle:XactClaimReport");
  652.         $ClaimReport = $ClaimReportRepo->findOneBy(['claimNumber' => $claim->getClaimNumber()]);
  653.         if (!empty($ClaimReport)) {
  654.             $ClaimReport->setReturnedDate($currentDate);
  655.             $em->persist($ClaimReport);
  656.             $em->flush();
  657.         }
  658.         $this->get('claim.status_update')->markQaRejected( $claim, $resource,$reason, $ReasonCodeIds, $currentDate->format("m/d/Y h:i A") );
  661.         return new JsonResponse(['error'=>false]);
  662.     }
  664.     /**
  665.      * @Route("/claim-diary/complete/{diary_id}", defaults={"diary_id" = null})
  666.      */
  667.     public function diaryComplete($diary_id)
  668.     {
  669.         $dispatch = $this->get('event_dispatcher');
  670.         $diaryEntry = $this->getDoctrine()->getRepository('ClaimManagementBundle:DiaryEntry')->find($diary_id);
  671.         $diaryEntry->setStatus(1);
  672.         $em = $this->getDoctrine()->getManager();
  673.         $em->persist($diaryEntry);
  674.         $em->flush();
  676.         /**
  677.          * @date 08/11/2017
  678.          *
  679.          * Implementing service to push a note to the Claim
  680.          *
  681.          */
  683.         $NoteService = $this->get('claim.note_provider');
  684.         // Todo ClaimDiaryAssignedEvent listener for this event
  685.         $dispatch->dispatch(ClaimDiaryCompleteEvent::NAME, new ClaimDiaryCompleteEvent($diaryEntry));
  686.         $NoteService->addClaimNote( $diaryEntry->getClaim(), "Diary entry '" . $diaryEntry->getDescription() . "' was completed!", false,70 );
  688.         return new JsonResponse(['diary'=> $diaryEntry->getId()]);
  689.     }
  691.     /**
  692.      * @Route("/create/claim-diary/{claim_id}/{diary_id}", defaults={"diary_id" = null})
  693.      */
  694.     public function addNewDiaryEntry($claim_id, $diary_id, Request $request)
  695.     {
  696.         $dispatch = $this->get('event_dispatcher');
  698.         // This is the EM we'll use
  699.         $em = $this->getDoctrine()->getManager();
  700.         $LoggedInUser = $this->container->get("security.token_storage")->getToken()->getUser();
  702.         if($claim_id){
  703.             $claim = $this->getDoctrine()->getRepository('ClaimManagementBundle:Claim')->find($claim_id);
  705.             $diaryFormData = $request->request->get('diary_form');
  707.             $isUpdate = false;
  708.             if ($diary_id) {
  709.                 $isUpdate = true;
  710.                 $diary = $this->getDoctrine()->getRepository('ClaimManagementBundle:DiaryEntry')->find($diary_id);
  711.             } else {
  712.                 $diary = new DiaryEntry();
  713.             }
  714.             $diaryForm = $this->createForm( DiaryFormType::class, $diary, ['claim_id' => $claim_id]);
  716.             $diaryForm->submit( $diaryFormData );
  718.             if($diaryForm->isValid()){
  720.                 /** @var DiaryEntry $DiaryEntry */
  721.                 $DiaryEntry = $diaryForm->getData();
  722.                 $DiaryEntry->setClaim($claim);
  723.                 $DiaryEntry->setAuthor($LoggedInUser);
  724.                 $DiaryEntry->setStatus(0);
  725.                 $DiaryEntry->setDateCreated( new \DateTime() );
  727.                 /**
  728.                  * @date 08/11/2017
  729.                  *
  730.                  * Implementing service to push a note to the Claim
  731.                  *
  732.                  */
  733.                 $NoteService = $this->get('claim.note_provider');
  734.                 // Todo ClaimDiaryAssignedEvent listener for this event
  735.                 if ($isUpdate == false) {
  736.                     $dispatch->dispatch(ClaimDiaryAssignedEvent::NAME, new ClaimDiaryAssignedEvent($diary));
  737.                     $NoteService->addClaimNote($DiaryEntry->getClaim(), "Diary entry '" . $DiaryEntry->getDescription() . "' was created!", false, 70);
  738.                 } else {
  739.                     $NoteService->addClaimNote($DiaryEntry->getClaim(), "Diary entry '" . $DiaryEntry->getDescription() . "' was updated!", false, 70);
  740.                 }
  742.                 /**
  743.                  * @date 08/31/2017
  744.                  *
  745.                  * Implementing multiple diary resources (if they exist)
  746.                  *
  747.                  */
  748.                 $other_resources = $request->request->get('extra-diary-resources');
  749.                 if($other_resources && !empty($other_resources)){
  750.                     foreach($other_resources as $resource_id){
  751.                         $ActualResource = $em->find("ResourceManagementBundle:Resource", $resource_id);
  752.                         $DiaryResource = new DiaryOtherResource();
  753.                         $DiaryResource->setDateAdded( new \DateTime() );
  754.                         $DiaryResource->setDiaryEntry( $DiaryEntry );
  755.                         $DiaryResource->setResource( $ActualResource );
  756.                         $em->persist($DiaryResource);
  757.                     }
  758.                 }
  760.                 $em->persist($DiaryEntry);
  761.                 $em->flush();
  765.                 $response['error'] = false;
  767.             }else{
  768.                 $response = [];
  769.                 $response['error'] = true;
  770.                 $response['formError'] = (string)$diaryForm->getErrors(true);
  771.                 foreach($diaryForm as $formField){
  772.                     $errorString = (string)$formField->getErrors();
  773.                     if($errorString != ""){
  774.                         $response['data']['errors'][] = [
  775.                             'id' => $diaryForm->getName()."_".$formField->getName(),
  776.                             'text' => $errorString
  777.                         ];
  778.                     }
  779.                 }
  780.             }
  782.             return new JsonResponse($response);
  783.         }else{
  784.             throw new NotFoundHttpException("Couldn't find this claim!");
  785.         }
  786.     }
  788.     /**
  789.      * @Route("/create/auto_disbursement")
  790.      */
  791.     public function addNewAutoDisbursement(Request $request)
  792.     {
  793.         // This is the EM we'll use
  794.         $em = $this->getDoctrine()->getManager();
  796.         $claimId = $request->request->get('claim');
  797.         $lastIdentifier = $request->request->get('lastIdentifier');
  799.         # JsonResponseObj
  800.         $rtnVal = [
  801.             'error' => false,
  802.             'errors' => [],
  803.             'data' => []
  804.         ];
  805.         $nHasQty = 0;
  806.         for($i = 0; $i < $lastIdentifier; $i++) {
  807.             $autoExpense = $request->request->get('auto-expense-' . $i);
  809.             if(!$autoExpense) {
  810.                 # if section of form doesnt exist, stop
  811.                 return new JsonResponse($rtnVal);
  812.             } else if ($autoExpense['qty'] == "") {
  813.                 # if quantity was not set, do not submit
  814.                 $rtnVal['error'] = true;
  815.                 $rtnVal['errors'][] = "Must set a quantity!";
  816.             } else {
  817.                 $nHasQty++;
  818.                 # set values
  819.                 $cost  = floatval(ltrim($autoExpense['amount'], '$'));
  820.                 $description = $autoExpense['description'];
  821.                 $qty = $autoExpense['qty'];
  822.                 $customerExpense = $autoExpense['customerExpense'];
  823.                 $expense = $autoExpense['expense'];
  824.                 $resource = $this->get('security.token_storage')->getToken()->getUser()->getId();
  826.                 # prepared statement for fast entries
  827.                 /*$sql = "INSERT INTO disbursement
  828.                     (claim_id, invoice_id, resource_id, expense_id, customer_expense_id, quantity, cost, description, dateCreated)
  829.                         VALUES
  830.                     ('" . $claimId . "', NULL,'" . $resource . "','" . $expense . "', '" . $customerExpense . "', '" . $qty . "', '" . $cost . "', '" . $description . "', NOW())";
  831.                 $stmt = $em->getConnection()->prepare($sql);
  832.                 $stmt->execute();*/
  834.                 $disbursement = new Disbursement();
  835.                 $disbursement->setClaim( $em->find("ClaimManagementBundle:Claim", $claimId) );
  836.                 $disbursement->setResource( $em->find("ResourceManagementBundle:Resource", $resource) );
  837.                 $disbursement->setExpense( $em->find("CompanyManagementBundle:Expense", $expense) );
  838.                 $disbursement->setCustomerExpense( $em->find("InvoiceManagementBundle:CustomerExpense", $customerExpense) );
  839.                 $disbursement->setQuantity($qty);
  840.                 $disbursement->setCost($cost);
  841.                 $disbursement->setDescription( $description );
  842.                 $disbursement->setDateCreated( new \DateTime() );
  844.                 $em->persist($disbursement);
  846.                 $em->flush();
  848.             }
  849.         }
  850.         //Give Error only if none of expenses have Qty
  851.         if (!empty($nHasQty)) {
  852.             $rtnVal = [
  853.                 'error' => false,
  854.                 'errors' => [],
  855.                 'data' => []
  856.             ];
  857.         }
  858.         //Give Error only if none of expenses have Qty
  859.         return new JsonResponse($rtnVal);
  860.     }
  862.     /**
  863.      * @Route("/create/expense/{id}")
  864.      * @ParamConverter("claim", class="ClaimManagementBundle:Claim")
  865.      */
  866.     public function createClaimExpenseAction($claim, Request $request)
  867.     {
  868.         // This is the EM we'll use
  869.         $em = $this->getDoctrine()->getManager();
  871.         // This extract gets submitted through the form builder
  872.         $time_log = $request->request->get('disbursement_time_log');
  874.         // This extract gets used only if the form submitted fully (to complete adding a new disbursement)
  875.         $time_log_extras = $request->request->get('disbursement_other');
  876.         
  877.         if ($time_log['expense'] < 1) {
  879.             $errors2 = array();
  880.             $data = [
  881.                 "errors" => array()
  882.             ];
  883.             $nextError = array();
  884.             $nextError['id'] = "choose-expense";
  885.             $nextError['text'] = "Please choose an expense.";
  886.             $data['errors'][] = $nextError;
  888.             # return json error objects
  889.             $retVal = array(
  890.                 "status" => "fail",
  891.                 "error_msgs" => $errors2,
  892.                 "error" => true,
  893.                 "data" => $data
  894.             );
  895.             return new JsonResponse($retVal);
  896.         }
  897.         # validate the resource on expense model with resource which assignments
  898.         $resourceId = $time_log['resource'];
  900.         /** @var \PDO $pdo */
  901.         $pdo = $em->getConnection();
  902.         $chkAdjusterAssinged = $pdo->prepare("SELECT resource_id, assignment_party_id, is_primary_adjuster  FROM assignments WHERE claim_id = ? AND resource_id = ? AND is_current_assignment = 1;");
  903.         $chkAdjusterAssinged->execute([$claim->getId(), $resourceId]);
  904.         if ($chkAdjusterAssinged->rowCount() == 0) {
  905.             # return json error objects
  906.             $nextError = array();
  907.             $nextError['id'] = "resource";
  908.             $nextError['text'] = "Resource set for expense is not assinged to claim.";
  909.             $data['errors'][] = $nextError;
  910.             $retVal = array(
  911.                 "status" => "fail",
  912.                 "error_msgs" => array(),
  913.                 "error" => true,
  914.                 "data" => $data
  915.             );
  916.             return new JsonResponse($retVal);
  917.         }
  918.         // Create the form
  919.         $form = $this->createForm(DisbursementTimeLogType::class, new Disbursement(), array('claim_id' => $claim->getId()));
  921.         /**
  922.          * @date 8/14/2017
  923.          *
  924.          * Fix to pre-select a date even if one has'nt been chosen in the front end.
  925.          * We always default to today's date.
  926.          */
  927.         /*$today = new \DateTime();
  928.         $time_log['dateCreated'] = $today->format("Y-m-d");*/
  930.         $form->submit($time_log);
  932.         if($form->isValid()){  // if form is valid
  934.             /** @var Disbursement $Disbursement */
  935.             $Disbursement = $form->getData();
  936.             $Disbursement->setClaim($claim);
  939.             if( $time_log_extras['customerExpense'] > 0 ){
  940.                 $CustomerExpense = $em->find('InvoiceManagementBundle:CustomerExpense', intval($time_log_extras['customerExpense']));
  941.                 $Disbursement->setCustomerExpense($CustomerExpense);
  942.             }
  943.             $Disbursement->setCost($time_log['cost']);
  944.             $Disbursement->setExcludeInvoicing($Disbursement->getExpense()->getExcludeInvoicing());// for excluding when expense default rate is 100
  945.             $em->persist($Disbursement);
  946.             $em->flush();
  948.             if (!$Disbursement->getExpense()->getExcludeInvoicing()) {
  949.                 # Update the Discount Amounts on the Disbursements, such as DiscountQty and MaxAmounts
  950.                 $invoiceService = $this->container->get("app.invoice_helper");
  951.                 $invoiceService->updateDisbursementDiscounts($claim);
  952.             }
  954.             $ClaimNote = $this->container->get("claim.note_provider");
  955.             //Status note = 69 Claim Disbursement
  956.             $ClaimNote->addClaimNote($claim, "Disbursement " . $Disbursement->getExpense()->getExpenseName() . " was added on Claim.", false, 69);
  958.             # pass json response success
  959.             $retVal = array(
  960.                 "status" => "success",
  961.                 "error_msgs" => []
  962.             );
  963.             return new JsonResponse($retVal);
  965.         }else{  // if form has errors
  967.             $data = array();
  968.             $errors2 = array();
  969.             $errorsArr = array();
  971.             # Get Error Messages
  972.             $error_str = (string)$form->getErrors(true, false);
  974.             $slog = new SLogger();
  975.             $slog->log("error_str at 2: ");
  976.             $slog->log($error_str);
  978.             $errorsArr2 = explode("\n", $error_str);
  979.             foreach ($errorsArr2 as $getError) {
  980.                 if (trim($getError) != "") {
  981.                     $errorsArr[] = trim($getError);
  982.                 }
  983.             }
  984.             $i = 1;
  985.             if (count($errorsArr) > 0) {
  986.                 $data = [
  987.                     "errors" => array()
  988.                 ];
  989.                 foreach ($errorsArr as $getItem) {
  990.                     if ($i == 1) {
  991.                         $nextError = array();
  992.                         $nextError['id'] = substr($getItem, 0, strlen($getItem) - 1);
  993.                     } else {
  994.                         $nextError['text'] = $getItem;
  995.                         $data['errors'][] = $nextError;
  996.                     }
  997.                     if ($i < 2) {
  998.                         $i++;
  999.                     } else {
  1000.                         $i = 1;
  1001.                     }
  1002.                 }
  1003.             }
  1005.             # return json error objects
  1006.             $retVal = array(
  1007.                 "status" => "fail",
  1008.                 "error_msgs" => $errors2,
  1009.                 "error" => true,
  1010.                 "data" => $data
  1011.             );
  1012.             return new JsonResponse($retVal);
  1014.         }
  1015.     }
  1017.     /**
  1018.      * @Route("/update/expense/{claimId}/{disbursementId}")
  1019.      */
  1020.     public function updateClaimExpenseAction(Request $request, $claimId, $disbursementId)
  1021.     {
  1022.         // This is the EM we'll use
  1023.         $em = $this->getDoctrine()->getManager();
  1025.         $claim = $em->getRepository("ClaimManagementBundle:Claim")->find($claimId);
  1026.         $disbursement = $em->getRepository("InvoiceManagementBundle:Disbursement")->find($disbursementId);
  1029.         ## Code checks if changes were made to Claim Object ##
  1030.         # Get Current Resource on DB
  1031.         $disbursement_compare = new DisbursementCompareHelper($em);
  1032.         # this function must be called before $form->getData()
  1033.         $disbursement_compare->setCurDisbursement($disbursement);
  1036.         // This extract gets submitted through the form builder
  1037.         $time_log = $request->request->get('disbursement_time_log');
  1039.         // This extract gets used only if the form submitted fully (to complete adding a new disbursement)
  1040.         $time_log_extras = $request->request->get('disbursement_other');
  1042.         // This extract gets used only if the expense cost is not editable
  1043.         $editable = $request->request->get('is_editable');
  1045.         // Create the form
  1046.         $form = $this->createForm( DisbursementTimeLogType::class, $disbursement, array('claim_id' => $claimId));
  1047.         $form->submit($time_log);
  1049.         // backend validation to validate cost cant be changed
  1050.         if ($editable != 1) {
  1051.             $cost = $time_log['cost'];
  1052.             if ($cost != $disbursement->getCost()) {
  1053.                 $errors2 = array();
  1054.                 $data = [
  1055.                     "errors" => array()
  1056.                 ];
  1057.                 $nextError = array();
  1058.                 $nextError['id'] = "not-editable";
  1059.                 $nextError['text'] = "The cost is not editable for this claim.";
  1060.                 $data['errors'][] = $nextError;
  1062.                 # return json error objects
  1063.                 $retVal = array(
  1064.                     "status" => "fail",
  1065.                     "error_msgs" => $errors2,
  1066.                     "error" => true,
  1067.                     "data" => $data
  1068.                 );
  1069.                 return new JsonResponse($retVal);
  1070.             }
  1071.         }
  1072.         if ($time_log['expense'] < 1) {
  1074.             $errors2 = array();
  1075.             $data = [
  1076.                 "errors" => array()
  1077.             ];
  1078.             $nextError = array();
  1079.             $nextError['id'] = "choose-expense";
  1080.             $nextError['text'] = "Please choose an expense.";
  1081.             $data['errors'][] = $nextError;
  1083.             # return json error objects
  1084.             $retVal = array(
  1085.                 "status" => "fail",
  1086.                 "error_msgs" => $errors2,
  1087.                 "error" => true,
  1088.                 "data" => $data
  1089.             );
  1090.             return new JsonResponse($retVal);
  1091.         }
  1093.         if($form->isValid()){  // if form is valid
  1095.             /** @var Disbursement $Disbursement */
  1096.             $Disbursement = $form->getData();
  1098.             if( $time_log_extras['customerExpense'] > 0 ){
  1099.                 $CustomerExpense = $em->find('InvoiceManagementBundle:CustomerExpense', intval($time_log_extras['customerExpense']));
  1100.                 $Disbursement->setCustomerExpense($CustomerExpense);
  1101.             }
  1103.             if( $time_log['expense'] > 0 ){
  1104.                 $Expense = $em->find("CompanyManagementBundle:Expense", intval($time_log['expense']));
  1105.                 $Disbursement->setExpense($Expense);
  1106.             }
  1108.             $Disbursement->setExcludeInvoicing($Disbursement->getExpense()->getExcludeInvoicing());// for excluding when expense default rate is 100
  1110.             # Get Submitted Form Claim Object
  1111.             $disbursement_compare->setNewDisbursement($Disbursement);
  1112.             # Compare 2 objects to see if there were any changes made
  1113.             $hasChanges = $disbursement_compare->compareObjects();
  1115.             if ($hasChanges) {
  1116.                 $em->persist($Disbursement);
  1117.                 $em->flush();
  1119.                 $ClaimNote = $this->container->get("claim.note_provider");
  1120.                 //Status note = 69 Claim Disbursement
  1121.                 $ClaimNote->addClaimNote($claim, "Disbursement " . $Disbursement->getExpense()->getExpenseName() . " was updated on Claim. " . implode(" ", $disbursement_compare->changeLog), false, 69);
  1122.             }
  1124.             if (!$Disbursement->getExpense()->getExcludeInvoicing()) {
  1125.                 # Update the Discount Amounts on the Disbursements, such as DiscountQty and MaxAmounts
  1126.                 $invoiceService = $this->container->get("app.invoice_helper");
  1127.                 $invoiceService->updateDisbursementDiscounts($claim);
  1128.             }
  1130.             # pass json response success
  1131.             $retVal = array(
  1132.                 "status" => "success",
  1133.                 "error" => false
  1134.             );
  1135.             return new JsonResponse($retVal);
  1137.         }else{  // if form has errors
  1139.             # Catch errors in a array
  1140.             $response = [];
  1141.             $response['error'] = true;
  1142.             $response['formError'] = (string)$form->getErrors(true);
  1143.             # foreach through each field for validation
  1144.             foreach($form as $formField){
  1145.                 $errorString = (string)$formField->getErrors();
  1146.                 if($errorString != ""){
  1147.                     $response['data']['errors'][] = [
  1148.                         'id' => $form->getName()."_".$formField->getName(),
  1149.                         'text' => $errorString
  1150.                     ];
  1151.                 }
  1152.             }
  1153.             return new JsonResponse($response);
  1157.         }
  1158.     }
  1162.     /**
  1163.      * @Route("/make/document_templates")
  1164.      */
  1165.     public function makeGlobalDocumentTemplates()
  1166.     {
  1167.         $kernel = $this->container->get("kernel");
  1168.         $file_path = $kernel->getRootDir() . "/Resources/doc_library";
  1170.         $finder = new Finder();
  1171.         $finder->files()->in($file_path);
  1173.         $fileArr = array();
  1174.         foreach ($finder as $file) {
  1175.             $file_name = $file->getRelativePathname();
  1176.             $file_path = $file->getRealPath();
  1178.             $fileNameArr = explode("-", $file_name);
  1179.             $index = $fileNameArr[0];
  1181.             $fileArr[$index] = [
  1182.                 "name" => $fileNameArr[1],
  1183.                 "path" => $file_path
  1184.             ];
  1186.         }
  1187.         ksort($fileArr);
  1189.         $idsArr = [
  1190.             "1" => 638,
  1191.             "2" => 639,
  1192.             "3" => 640,
  1193.             "4" => 641,
  1194.             "5" => 642,
  1195.             "6" => 643,
  1196.             "7" => 644
  1197.         ];
  1198.         $file_manager = $this->container->get("app.file_manager");
  1199.         foreach ($fileArr as $index => $getFile) {
  1200.             $fh = fopen($getFile['path'], 'r');
  1201.             $content = fread($fh, filesize($getFile['path']));
  1202.             fclose($fh);
  1204.             # Convert HTML Content to PDF file in /tmp folder
  1205.             $get_num = md5(uniqid());
  1206.             $new_file_name = $get_num;
  1207.             $new_file_path = "/tmp/" . $new_file_name;
  1209.             $fh1 = fopen($new_file_path, 'w');
  1210.             fwrite($fh1, $content);
  1211.             fclose($fh1);
  1213.             # Create file from temp file using file manager service
  1214.             $useFile['new_file_name'] = $new_file_name;
  1215.             $useFile['used_by_module'] = "DocumentLibraryGlobal";
  1217.             $useFile['name'] = $new_file_name;
  1218.             $useFile['type'] = "text/html";
  1219.             $useFile['error'] = 0;
  1220.             $useFile['size'] = filesize($new_file_path);
  1221.             $useFile['file_ext'] = "twig";
  1223.             # Save file by passing file object, id, and entity name
  1224.             $file_manager->saveFile($useFile, $idsArr[$index], "DocumentLibraryGlobal");
  1225.         }
  1227.         dump("Script completed");
  1228.         die;
  1229.     }
  1235.     /**
  1236.      * @Route("/make/document_templates2")
  1237.      */
  1238.     public function makeGlobalDocumentTemplates2()
  1239.     {
  1240.         $kernel = $this->container->get("kernel");
  1241.         $file_path = $kernel->getRootDir() . "/Resources/doc_library2";
  1243.         $finder = new Finder();
  1244.         $finder->files()->in($file_path);
  1246.         $fileArr = array();
  1247.         foreach ($finder as $file) {
  1248.             $file_name = $file->getRelativePathname();
  1249.             $file_path = $file->getRealPath();
  1251.             $fileNameArr = explode("-", $file_name);
  1252.             $index = $fileNameArr[0];
  1254.             $fileArr[$index] = [
  1255.                 "name" => $fileNameArr[1],
  1256.                 "path" => $file_path
  1257.             ];
  1259.         }
  1260.         ksort($fileArr);
  1262.         $idsArr = [
  1263.             "8" => 645,
  1264.             "9" => 646,
  1265.             "10" => 647
  1266.         ];
  1267.         $file_manager = $this->container->get("app.file_manager");
  1268.         foreach ($fileArr as $index => $getFile) {
  1269.             $fh = fopen($getFile['path'], 'r');
  1270.             $content = fread($fh, filesize($getFile['path']));
  1271.             fclose($fh);
  1273.             # Convert HTML Content to PDF file in /tmp folder
  1274.             $get_num = md5(uniqid());
  1275.             $new_file_name = $get_num;
  1276.             $new_file_path = "/tmp/" . $new_file_name;
  1278.             $fh1 = fopen($new_file_path, 'w');
  1279.             fwrite($fh1, $content);
  1280.             fclose($fh1);
  1282.             # Create file from temp file using file manager service
  1283.             $useFile['new_file_name'] = $new_file_name;
  1284.             $useFile['used_by_module'] = "DocumentLibraryGlobal";
  1286.             $useFile['name'] = $new_file_name;
  1287.             $useFile['type'] = "text/html";
  1288.             $useFile['error'] = 0;
  1289.             $useFile['size'] = filesize($new_file_path);
  1290.             $useFile['file_ext'] = "twig";
  1292.             # Save file by passing file object, id, and entity name
  1293.             $file_manager->saveFile($useFile, $idsArr[$index], "DocumentLibraryGlobal");
  1294.         }
  1296.         dump("Script completed");
  1297.         die;
  1298.     }
  1300.     /**
  1301.      * @Route("/share/claim-resources/{id}")
  1302.      * @Method(methods={"POST"})
  1303.      * @deprecated
  1304.      */
  1305.     public function completeShareResource(Request $request, Claim $claim)
  1306.     {
  1307.         $em = $this->container->get("doctrine.orm.entity_manager");
  1308.         if ($claim == null) {
  1309.             throw $this->createNotFoundException("Claim does not exist");
  1310.         }
  1312.         # Request Adjuster Info
  1313.         $roles = $request->request->get("roles");
  1314.         $AdjustersArr = $roles;
  1316.         # Check if duplicate adjusters have been passed
  1317.         $hasDuplicates = false;
  1318.         $allAdjusters = array();
  1319.         $duplicateAdjusterType = "";
  1320.         foreach ($AdjustersArr as $adjusterType => $adjusterIds) {
  1321.             foreach ($adjusterIds as $adjusterId) {
  1322.                 if (in_array($adjusterId, $allAdjusters)) {
  1323.                     $hasDuplicates = true;
  1324.                     $duplicateAdjusterType = $adjusterType;
  1325.                     break;
  1326.                 }
  1327.                 $allAdjusters[] = $adjusterId;
  1328.             }
  1329.         }
  1331.         if ($hasDuplicates) {  // if duplicate adjusters were sent
  1333.             # Send Back Error
  1334.             $errors2 = array();
  1335.             $data = [
  1336.                 "errors" => array()
  1337.             ];
  1338.             $nextError = array();
  1339.             $nextError['id'] = $duplicateAdjusterType;
  1340.             $nextError['text'] = "You cannot assign the same Adjuster more than once on this Claim.";
  1341.             $data['errors'][] = $nextError;
  1343.             $response = array(
  1344.                 "result" => "fail",
  1345.                 "error_msgs" => $errors2,
  1346.                 "error" => true,
  1347.                 "data" => $data
  1348.             );
  1349.             return new JsonResponse($response);
  1350.         } else {
  1354.             # First Validate that all adjusters can be added
  1355.             $allErrors = array();
  1356.             foreach ($AdjustersArr as $adjusterType => $adjusterIds) {
  1358.                 $getAdjustertype = $adjusterType;
  1359.                 $role = $em->getRepository("ClaimManagementBundle:ClaimResourceRole")->findOneBy([
  1360.                     "role" => $getAdjustertype
  1361.                 ]);
  1362.                 foreach ($adjusterIds as $adjusterId) {
  1364.                     if ($getAdjustertype == "Field Adjuster" || $getAdjustertype == "Desk Adjuster") {  // if field or desk
  1365.                         $adjusters = $em->getRepository("ClaimManagementBundle:ClaimResource")->getAdjustersByClaim($claim);
  1367.                         if (count($adjusters) == 0) {  // if no adjusters
  1368.                             # Set Primary
  1369.                             $isPrimary = true;
  1370.                         } else {
  1372.                             if ($getAdjustertype == "Field Adjuster") {  // if current type is field adjuster
  1373.                                 $fieldAdjustersCount = 0;
  1374.                                 foreach ($adjusters as $getAdjuster) {
  1375.                                     if ($getAdjuster->getResource->getRole()->getRole() == "Field Adjuster") {
  1376.                                         $fieldAdjustersCount++;
  1377.                                     }
  1378.                                 }
  1379.                                 if ($fieldAdjustersCount == 0) {  // if there are no other field adjusters
  1380.                                     # Set Primary
  1381.                                     $isPrimary = true;
  1382.                                 } else {
  1383.                                     $isPrimary = false;
  1384.                                 }
  1385.                             } else {
  1386.                                 $isPrimary = false;
  1387.                             }
  1388.                         }
  1389.                     } else {
  1390.                         $isPrimary = false;
  1391.                     }
  1392.                     $currentResource = $em->getRepository("ResourceManagementBundle:Resource")->find($adjusterId);
  1394.                     # Attempt assigning the RESOURCE to the CLAIM
  1395.                     $retVal = $this->get('claim.assignment')->validateAssignResourceToClaim(
  1396.                         $claim,
  1397.                         $currentResource,
  1398.                         $role,
  1399.                         new \DateTime(),
  1400.                         $isPrimary,
  1401.                         $currentResource->getPayrollId()
  1402.                     );
  1404.                     $errors = $this->get('claim.assignment')->getErrors();
  1405.                     $allErrors = $errors;
  1407.                     if ($retVal == false) {   // if adding some of the adjusters returned errors
  1409.                         # Send Error Messages
  1410.                         if (!empty($allErrors)) {
  1412.                             $errors2 = array();
  1413.                             $data = [
  1414.                                 "errors" => array()
  1415.                             ];
  1416.                             $nextError = array();
  1417.                             $nextError['id'] = "";
  1418.                             $nextError['text'] = implode("\n", $allErrors);
  1419.                             $data['errors'][] = $nextError;
  1421.                             $response = array(
  1422.                                 "result" => "fail",
  1423.                                 "error_msgs" => $errors2,
  1424.                                 "error" => true,
  1425.                                 "data" => $data
  1426.                             );
  1428.                             return new JsonResponse($response);
  1429.                             exit;
  1430.                         }
  1431.                     }
  1432.                 }
  1433.             }
  1435.             # If all adjusters can be added, go ahead and assign them
  1436.             foreach ($AdjustersArr as $adjusterType => $adjusterIds) {
  1438.                 $getAdjustertype = $adjusterType;
  1439.                 $role = $em->getRepository("ClaimManagementBundle:ClaimResourceRole")->findOneBy([
  1440.                     "role" => $getAdjustertype
  1441.                 ]);
  1442.                 foreach ($adjusterIds as $adjusterId) {
  1444.                     if ($getAdjustertype == "Field Adjuster" || $getAdjustertype == "Desk Adjuster") {  // if field or desk
  1446.                         $adjusters = $em->getRepository("ClaimManagementBundle:ClaimResource")->getAdjustersByClaim($claim);
  1448.                         if (count($adjusters) == 0) {  // if no adjusters
  1449.                             # Set Primary
  1450.                             $isPrimary = true;
  1451.                         } else {
  1453.                             if ($getAdjustertype == "Field Adjuster") {  // if current type is field adjuster
  1454.                                 $fieldAdjustersCount = 0;
  1455.                                 foreach ($adjusters as $getAdjuster) {
  1456.                                     if ($getAdjuster->getRole()->getRole() == "Field Adjuster") {
  1457.                                         $fieldAdjustersCount++;
  1458.                                     }
  1459.                                 }
  1460.                                 if ($fieldAdjustersCount == 0) {  // if there are no other field adjusters
  1461.                                     # Set Primary
  1462.                                     $isPrimary = true;
  1463.                                 } else {
  1464.                                     $isPrimary = false;
  1465.                                 }
  1466.                             } else {
  1467.                                 $isPrimary = false;
  1468.                             }
  1469.                         }
  1470.                     } else {
  1471.                         $isPrimary = false;
  1472.                     }
  1473.                     $currentResource = $em->getRepository("ResourceManagementBundle:Resource")->find($adjusterId);
  1475.                     $this->get('claim.assignment')->assignResourceToClaim(
  1476.                         $claim,
  1477.                         $currentResource,
  1478.                         $role,
  1479.                         new \DateTime(),
  1480.                         $isPrimary,
  1481.                         $currentResource->getPayrollId()
  1482.                     );
  1483.                 }
  1484.             }
  1486.             # Return success JSON
  1487.             $response = array(
  1488.                 "result" => "success",
  1489.                 "error_msgs" => []
  1490.             );
  1491.             return new JsonResponse($response);
  1492.         }
  1493.     }
  1495.     /**
  1496.      * @Route("/verify/claim-resource")
  1497.      */
  1498.     public function verifyShareResource(Request $request)
  1499.     {
  1500.         // We want to know what RESOURCE is going into WHAT role, and WHAT claim.. so.
  1501.         if($request && $request->get('claim') && $request->get('resource')){
  1503.             # Load the IDs from the GET request
  1504.             $claim_id = $request->get('claim');
  1505.             $resource_id = $request->get('resource');
  1506.             $role_name = $request->get('role');
  1508.             # Load them now into the ENTITIES
  1509.             $em = $this->getDoctrine()->getManager();
  1511.             # Entity mapping
  1512.             $Claim = $em->find("ClaimManagementBundle:Claim", $claim_id);
  1513.             $Role = $em->getRepository('ClaimManagementBundle:ClaimResourceRole')->findOneBy(['role'=>$role_name]);
  1514.             $Resource = $em->find("ResourceManagementBundle:Resource", $resource_id);
  1516.             # Service to call
  1517.             $claimService = $this->get('claim.assignment');
  1519.             # Create the JSON response
  1520.             $json_response = [
  1521.                 'result' => false,
  1522.                 'messages' => []
  1523.             ];
  1525.             # Now, we verify if this Resource can be shared onto this Claim.. or if not.
  1526.             if($claimService->canAssignResourceToClaim($Claim, $Resource, $Role)){
  1527.                 // Send a result saying that it can be assigned, allow it
  1528.                 $json_response['result'] = true;
  1529.             }else{
  1530.                 // Send a result saying that for some reason this guy can't be added
  1531.                 $json_response['messages'] = $claimService->getErrors();
  1532.                 $json_response['messages'][] = 'Claim could not be assigned.';
  1533.             }
  1535.             return new JsonResponse($json_response);
  1536.         }else{
  1537.             throw new BadRequestHttpException('Please submit a CLAIM, ROLE and RESOURCE with your request');
  1538.         }
  1539.     }
  1540.     public function slugify($text)
  1541.     {
  1542.         $delimiter = "_";
  1543.         $text = iconv('utf-8', 'us-ascii//TRANSLIT', $text);
  1544.         return strtolower(preg_replace('/[^A-Za-z0-9-]+/', $delimiter, $text));
  1545.     }
  1546.     /**
  1547.      * @Route("ack-letter/send/{id}")
  1548.      */
  1549.     public function sendAckLetterEmail(Claim $claim, Request $request)
  1550.     {
  1551.         $em = $this->container->get('doctrine')->getManager();
  1552.         $tokenStorage = $this->container->get('security.token_storage');
  1553.         $user  = $tokenStorage->getToken()->getUser();
  1555.         $incoming_internal_rep = $request->request->get('intRepEmail');
  1556.         $incoming_addresses = $request->request->get('otherEmail');
  1557.         $incoming_body = $request->request->get('body');
  1558.         $kernel = $this->container->get('kernel');
  1559.         $env = $kernel->getEnvironment();
  1560.         $strImagePath = $this->generateUrl('globals_companymanagement_company_getcompanylogo', array('id'=>$claim->getId()));
  1561.         $strImagePathTmp = '';
  1562.         if ($claim->getCustomer()) {
  1563.             $ClaimCustomer = $claim->getCustomer();
  1565.             if ($ClaimCustomer->getSubCompany()) {  // if has a Company ID on the Claim Team
  1567.                 # Use that Sub Company ID
  1568.                 $company_id = $ClaimCustomer->getSubCompany()->getId();
  1570.                 $Company = $em->getRepository("CompanyManagementBundle:Company")->findById($company_id);
  1572.                 if ($Company) {
  1573.                     $entity = 'CompanyLogo';
  1574.                     $FileManager = $em->getRepository("ResourceManagementBundle:FileManager")->loadByFileIDEntity($company_id, $entity);
  1576.                     $fileName =  $this->slugify($Company[0]->getName());
  1577.                     $strImagePathTmp = $request->server->get('DOCUMENT_ROOT'). "/" . $kernel->getEnvironment() . "/" . $entity . "/" . $fileName . "." . $FileManager->getExt();
  1581.                 }
  1582.             }
  1583.         }
  1586.         $imageUrl = $request->server->get('DOCUMENT_ROOT')."/img/$env.jpg";
  1587.         if(!empty($strImagePathTmp)){
  1588.             $imageUrl = $strImagePathTmp;
  1589.         }
  1590.         if($incoming_addresses && $incoming_internal_rep){
  1591.             $incoming_addresses .=  ";$incoming_internal_rep";
  1592.         }else{
  1593.             $incoming_addresses .=  $incoming_internal_rep;
  1594.         }
  1595.         if ($incoming_addresses && $claim->getClientEmail()) {
  1596.             $clientEmail = $claim->getClientEmail();
  1597.             $incoming_addresses .=  ";$clientEmail";
  1598.         }
  1599.         
  1601.         $addresses = explode(';', $incoming_addresses);
  1603.         $email_from = $user->getEmail();
  1604.         $subject = "Acknowledgment Letter";
  1606.         $email_body = $incoming_body;
  1608.         $mailer = $this->container->get('mail_management.mailer');
  1609.         $mailer->replaceParam = array('strImagePath' => $strImagePath, 'imageUrl' => $imageUrl);
  1610.         $Mail = new Mail();
  1611.         $mailer->setSendingConfig();
  1612.         foreach ($addresses as $address) {
  1614.             //Validate Emails
  1615.             if (!filter_var($address, FILTER_VALIDATE_EMAIL)) {
  1616.                 return new JsonResponse(['error'=>true, 'data' => ['errors' => "Wrong email format"]]);
  1617.             }
  1618.             $slog = new SLogger();
  1620.             $slog->log('address: '.$address);
  1622.             $email_to = $address;
  1624.             # Recipient
  1625.             $Recipient = new MailRecipient();
  1626.             $Recipient->setEmail($email_to);
  1627.             $Recipient->setMail($Mail);
  1628.             $Recipient->setRecipientId($claim->getCustomer()->getId());
  1629.             $entityName = $em->getMetadataFactory()->getMetadataFor(get_class($claim->getCustomer()))->getName();
  1630.             $Recipient->setRecipientType($entityName);
  1631.             //$em->persist( $Recipient ); 
  1632.             //$em->flush();
  1633.             # Adds the single recipient (resource);
  1634.             $Mail->addRecipient($Recipient);
  1635.             $Mail->setSubject($subject);
  1637.             # SETTING THE EXCEPTIONS
  1638.             # ######################################################
  1639.             $catcrew_exceptions = false;
  1640.             $great_american_exception = false;
  1642.             if($claim->getCustomer()->getId() == 5624)
  1643.             {
  1644.                 $great_american_exception = true;;
  1645.             }
  1647.             if($claim->getCustomer()->getId() == 5727)
  1648.             {
  1649.                 $catcrew_exceptions = true;
  1650.             }
  1651.         }
  1653.             # SETTING THE SUBJECT
  1654.             # ######################################################
  1655.             // $Mail->setSubject("Claim Assigned");
  1656.             $Mail->setSubject("Claim has been assigned - Claim Assigned Notification");
  1658.             if($great_american_exception)
  1659.             {
  1660.                 $SubjectClaim = str_replace("-","",$claim->getClaimNumber());
  1661.                 $Mail->setSubject($SubjectClaim.";Documents;Other;Acknowledgement Davies;;;;Financial Institution Services;;;;;;;Spec Gen;;;;;N;;;");
  1662.             }
  1664.             if($catcrew_exceptions)
  1665.             {
  1666.                 $Mail->setSubject("Acknowledgement for Claim #" . $claim->getClaimNumber());
  1667.             }
  1669.             # Finalize the MAIL object
  1670.             $Mail->setBody($email_body);
  1671.             $Mail->setSenderName(MailHelper::getMailSenderName($tokenStorage));
  1672.             $mailer->sendEmail($Mail, $email_from, "");
  1674.         /*
  1675.          * Create a Claim Note in the FileNotes
  1676.          */
  1677.         // status note = 71 Ack. Letter
  1678.         $this->container->get('claim.note_provider')->addClaimNote($claim, "Ack. Letter sent to " . $incoming_addresses . " by " . $email_from , true, 71);
  1680.         /*
  1681.          * Call function that converts to PDF and attach to Attachments List
  1682.          */
  1684.         $slog = new SLogger();
  1685.         $slog->log("123 789");
  1687.         $this->convertToAttachmentsAckLetter($incoming_body, $claim->getId(), $user->getId());
  1689.         //Update the claim table with pdfstatus in progress pdf stacking
  1690.         $update_claim_sql = "UPDATE claim 
  1691.                                 SET pdfstatus = :pdfstatus,
  1692.                                 updated_at = NOW()
  1693.                                 WHERE id = :claim_id";
  1694.         $dataParams = array();
  1695.         $dataParams['claim_id'] = $claim->getId();
  1696.         $dataParams['pdfstatus'] = 1;
  1697.         $stmt = $em->getConnection()->prepare($update_claim_sql);
  1699.         try{
  1700.             $stmt->execute($dataParams);
  1701.         }catch (\PDOException $e){
  1702.             return new Response("Exception occurred while Updating");
  1703.         }
  1705.         return new JsonResponse(['success' => true]);
  1706.     }
  1708.     /**
  1709.      * Function to Convert to PDF and Append to Attachments
  1710.      */
  1711.     public function convertToAttachmentsAckLetter($htmlBody, $claimId, $resourceId){
  1713.         $em = $this->container->get("doctrine.orm.entity_manager");
  1714.         $fileManager = $this->container->get("app.file_manager");
  1715.         $kernel = $this->container->get("kernel");
  1717.         /*
  1718.          * Create Path and File name
  1719.          */
  1720.         $new_file_name = md5(uniqid());
  1721.         $new_file_path = "/tmp/" . $new_file_name;
  1723.         $this->container->get("knp_snappy.pdf")->setTimeout(600);
  1725.         $slog = new SLogger();
  1726.         $slog->log("htmlBody at 712: " . $htmlBody);
  1727.         $slog->log("new_file_path: $new_file_path");
  1729.         $rootDir = $kernel->getRootDir();
  1730.         $rootDir = str_replace("/app", "", $rootDir);
  1732.         $htmlBody = str_replace("/" . $kernel->getEnvironment() . "/CompanyLogo/", $rootDir . "/web/" . $kernel->getEnvironment() . "/CompanyLogo/", $htmlBody);
  1734.         $slog->log("htmlBody after at 717: " . $htmlBody);
  1736.         $this->container->get("knp_snappy.pdf")->generateFromHtml($htmlBody, $new_file_path);
  1738.         $useFile['new_file_name'] = basename($new_file_path);
  1739.         $useFile['used_by_module'] = "ClaimReport";
  1740.         $useFile['name'] = basename($new_file_path);
  1741.         $useFile['type'] = "application/pdf";
  1742.         $useFile['error'] = 0;
  1744.         //            echo "<pre>";
  1745.         //                echo $new_file_path;
  1746.         //
  1747.         //                echo $htmlBody;
  1748.         //            echo "</pre>";
  1750.         try {
  1751.             $useFile['size'] = filesize($new_file_path);
  1753.         } catch (Exception $e) {
  1754.             return new JsonResponse(['error' => $e->getMessage()]);
  1755.         }
  1757.         /*
  1758.          * Insert into claim_report
  1759.          */
  1760.         $useFile['file_ext'] = "pdf";
  1762.         $sql = "INSERT INTO
  1763.                 claim_report(file_title,file_size,ext,created_on,claim_id,document_type_id,adjuster_id,invoice_id,status)
  1764.                 VALUES (:file_title, :file_size, :ext, :created_on, :claim_id, :document_type_id, :adjuster_id, :invoice_id, :status_id)";
  1766.         $dataParams = array();
  1767.         $dataParams['file_title'] = 'Acknowledgment Letter';
  1768.         $dataParams['file_size'] = $useFile['size'];
  1769.         $dataParams['ext'] = 'pdf';
  1770.         $dataParams['created_on'] = date('Y-m-d');
  1771.         $dataParams['claim_id'] = $claimId;
  1772.         $dataParams['document_type_id'] = 10;
  1773.         $dataParams['adjuster_id'] = $resourceId;
  1774.         $dataParams['invoice_id'] = 0;
  1775.         $dataParams['status_id'] = 1;
  1777.         $stmt = $em->getConnection()->prepare($sql);
  1779.         try {
  1780.             $stmt->execute($dataParams);
  1781.             $fileId = $em->getConnection()->lastInsertId();
  1783.         } catch (Exception $e) {
  1784.             return new JsonResponse(['error' => $e->getMessage()]);
  1785.         }
  1787.         /*
  1788.          * Wasabi Save File
  1789.          */
  1790.         if ($fileId) {
  1791.             //$fileId = $result['id'];
  1792.             $fileSave = $fileManager->saveFile($useFile, $fileId, "ClaimReport");
  1794.             if ($fileSave) {
  1795.                 # Return success JSON
  1796.                 $response = array(
  1797.                     "result" => "success",
  1798.                     "error_msgs" => [$fileSave]
  1799.                 );
  1800.             }else{
  1802.                 #if the file is not saved on wasabi delete it from claim report
  1803.                 $sql = "DELETE FROM claim_report WHERE id = :id";
  1804.                 $dataParams = array();
  1805.                 $dataParams['id'] = $fileId;
  1807.                 $stmt = $em->getConnection()->prepare($sql);
  1809.                 try {
  1810.                     $stmt->execute($dataParams);
  1811.                 } catch (Exception $e) {
  1812.                     return new JsonResponse(['error' => "Error deleting from claim report"]);
  1813.                 }
  1816.                 # Return wrong JSON
  1817.                 $response = array(
  1818.                     "result" => "error FileSave",
  1819.                     "error" => true,
  1820.                     "error_msgs" => [$fileSave]
  1821.                 );
  1822.             }
  1823.         }else{
  1824.             # Return wrong JSON
  1825.             $response = array(
  1826.                 "result" => "error fileId",
  1827.                 "error" => true,
  1828.                 "error_msgs" => [$fileId]
  1829.             );
  1830.         }
  1831.         return new JsonResponse($response);
  1832.     }
  1834.     /**
  1835.      * @Route("/update/duplicate-claim/{id}")
  1836.      * @ParamConverter("claim", class="ClaimManagementBundle:Claim")
  1837.      */
  1838.     public function duplicateClaim(Claim $claim, Request $request)
  1839.     {
  1841.         $response = ['error'=>false, 'data'=>[]];
  1842.         $em = $this->container->get("doctrine.orm.entity_manager");
  1845.         if($claim){
  1847.             $sql = "INSERT INTO claim 
  1848.                     (claim_number,
  1849.                     severity,
  1850.                     date_received,
  1851.                     status_id, 
  1852.                     claim_rep_id,
  1853.                     customer_id,
  1854.                     loss_date,
  1855.                     loss_street,
  1856.                     loss_city,
  1857.                     loss_state_id,
  1858.                     loss_zip,
  1859.                     peril_id,
  1860.                     sub_peril_id,
  1861.                     inspection_note,
  1862.                     policy_id,
  1863.                     policy_number,
  1864.                     policy_type,
  1865.                     policy_start_date,
  1866.                     policy_end_date,
  1867.                     loss_description,
  1868.                     loss_amount,
  1869.                     coinsurance,
  1870.                     mortgage,
  1871.                     form_numbers,
  1872.                     form_numbers_set,
  1873.                     report_due_date,
  1874.                     special_notes,
  1875.                     agent_id,
  1876.                     minor_bday,
  1877.                     parent,
  1878.                     date_created)
  1879.                     SELECT 
  1880.                     claim_number,
  1881.                     severity,
  1882.                     date_received,
  1883.                     5, 
  1884.                     claim_rep_id,
  1885.                     customer_id,
  1886.                     loss_date,
  1887.                     loss_street,
  1888.                     loss_city,
  1889.                     loss_state_id,
  1890.                     loss_zip,
  1891.                     peril_id,
  1892.                     sub_peril_id,
  1893.                     inspection_note,
  1894.                     policy_id,
  1895.                     policy_number,
  1896.                     policy_type,
  1897.                     policy_start_date,
  1898.                     policy_end_date,
  1899.                     loss_description,
  1900.                     loss_amount,
  1901.                     coinsurance,
  1902.                     mortgage,
  1903.                     form_numbers,
  1904.                     form_numbers_set,
  1905.                     report_due_date,
  1906.                     special_notes,
  1907.                     agent_id,
  1908.                     minor_bday,
  1909.                     id,
  1910.                     NOW()
  1911.                     FROM claim
  1912.                     WHERE id = :claim_id";
  1914.             $dataParams = array();
  1915.             $dataParams['claim_id'] = $claim->getId();
  1917.             $stmt = $em->getConnection()->prepare($sql);
  1919.             try {
  1920.                 $stmt->execute($dataParams);
  1921.                 $newClaimId = $em->getConnection()->lastInsertId();
  1923.             } catch (Exception $e) {
  1924.                 return new JsonResponse(['error' => true,'error_msg' => $e->getMessage()]);
  1925.             }
  1928.             #Copy the claim insured
  1929.             $sql = "INSERT INTO claims_insured(claim_id, claim_insured_type_id, file_no, insured_id, is_primary, minor_dob, minor_involved )
  1930.                     SELECT :new_claim_id, claim_insured_type_id, :new_claim_id, insured_id, is_primary, minor_dob, minor_involved 
  1931.                     FROM claims_insured
  1932.                     WHERE claim_id = :claim_id";
  1934.             $dataParams = array();
  1935.             $dataParams['claim_id'] = $claim->getId();
  1936.             $dataParams['new_claim_id'] = $newClaimId;
  1938.             $stmt = $em->getConnection()->prepare($sql);
  1940.             try {
  1941.                 $stmt->execute($dataParams);
  1943.             } catch (Exception $e) {
  1944.                 return new JsonResponse(['error' => true,'error_msg' => $e->getMessage()]);
  1945.             }
  1947.             #Copy the claim coverages
  1948.             $sql = "INSERT INTO coverage(claim_id, name, amount, reserve, coverage_type_id, user_changed_id, dateChanged, reasonChanged)
  1949.                     SELECT :new_claim_id, name, amount, reserve, coverage_type_id, user_changed_id, dateChanged, reasonChanged
  1950.                     FROM coverage 
  1951.                     WHERE claim_id = :claim_id";
  1953.             $dataParams = array();
  1954.             $dataParams['claim_id'] = $claim->getId();
  1955.             $dataParams['new_claim_id'] = $newClaimId;
  1957.             $stmt = $em->getConnection()->prepare($sql);
  1959.             try {
  1960.                 $stmt->execute($dataParams);
  1962.             } catch (Exception $e) {
  1963.                 return new JsonResponse(['error' => true,'error_msg' => $e->getMessage()]);
  1964.             }
  1967.             #Copy the claim deductibles
  1968.             $sql = "INSERT INTO deductible(claim_id, name, amount, deductible_name_id)
  1969.                     SELECT :new_claim_id, name, amount, deductible_name_id
  1970.                     FROM deductible 
  1971.                     WHERE claim_id = :claim_id";
  1973.             $dataParams = array();
  1974.             $dataParams['claim_id'] = $claim->getId();
  1975.             $dataParams['new_claim_id'] = $newClaimId;
  1977.             $stmt = $em->getConnection()->prepare($sql);
  1979.             try {
  1980.                 $stmt->execute($dataParams);
  1982.             } catch (Exception $e) {
  1983.                 return new JsonResponse(['error' => true,'error_msg' => $e->getMessage()]);
  1984.             }
  1985.             $newClaim = $this->getDoctrine()->getRepository('ClaimManagementBundle:Claim')->find($newClaimId);
  1986.             $response['data'] = $newClaimId;
  1987.             # logged in user
  1988.             $user = $this->get('security.token_storage')->getToken()->getUser();
  1989.             $NoteService = $this->get('claim.note_provider');
  1990.             $strComment = "New claim (copy claim) was duplicated from claim with FILE ID # ".$claim->getId()." by ".$user->getFullName(). " on ". date('m/d/Y h:i A');
  1991.             $NoteService->addClaimNote( $newClaim, $strComment, false,13 );
  1992.             // Notify event Claim is created
  1993.             $dispatcher = $this->get('event_dispatcher');
  1994.             $dispatcher->dispatch(new ClaimDuplicatedEvent($newClaim), ClaimDuplicatedEvent::NAME );
  1996.             return new JsonResponse($response);
  1997.         }else{
  1998.             throw new NotFoundHttpException("Couldn't find this claim!");
  1999.         }
  2000.     }
  2002.     /**
  2003.      * @Route("/update/claim-cwop-reason/{id}")
  2004.      * @ParamConverter("claim", class="ClaimManagementBundle:Claim")
  2005.      */
  2006.     public function updateClaimCwopReasonAction(Claim $claim, Request $request)
  2007.     {
  2008.         $cwop_reason = $request->request->get('cwop_reason');
  2009.         $em = $this->container->get("doctrine.orm.entity_manager");
  2010.         $denial_description_line = $request->request->get('denial_description_line');
  2011.         $objCwopReason = $em->getRepository("ClaimManagementBundle:CwopReason")->findOneBy(['id' => $cwop_reason]);
  2012.         if(empty($objCwopReason)){
  2013.             return new JsonResponse(['error'=>true, 'msg' => 'CWOP Reason not found']);
  2014.         }
  2015.         try{
  2016.             $ReopenDate = $claim->getDateReopened();
  2017.             $strReopen = "";
  2018.             if (!empty($ReopenDate)) {
  2019.                 $claim->setReopenCwopRsn($objCwopReason);
  2020.                 $claim->setReopenDenialDescriptionLine($denial_description_line);
  2021.                 $strReopen = "Reopen";
  2022.             }else{
  2023.                 $claim->setCwopReason($objCwopReason);
  2024.                 $claim->setDenialDescriptionLine($denial_description_line);
  2025.             }
  2026.             $em->persist($claim);
  2027.             $em->flush();
  2028.             $ClaimNote = $this->container->get("claim.note_provider");
  2029.             $strCWOPReason = $objCwopReason->getDescription();
  2030.             $ClaimNote->addClaimNote($claim, "$strReopen CWOP Reason ($strCWOPReason) added to the claim with Denial Description as ($denial_description_line).", false);
  2031.         }catch(Exception $e){
  2032.             return new JsonResponse(['error'=>true, 'msg' => $e->getMessage()]);
  2033.         }
  2034.         return new JsonResponse(['error'=>false]);
  2035.     }
  2036. }