src/Controller/Seo/SEOTasksController.php line 331

Open in your IDE?
  1. <?php
  3. namespace App\Controller\Seo;
  5. use App\Entity\Seo\SEOTasks;
  6. use App\Entity\Seo\GPlaces;
  7. use App\Entity\Seo\IntelQueue;
  8. use App\Entity\Seo\CompetitorPivot;
  9. use App\Entity\Seo\Locations;
  10. use App\Entity\Fp\FPTasks;
  11. use App\Form\SEOTasksType;
  12. use Doctrine\ORM\EntityManagerInterface;
  13. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  14. use Symfony\Component\HttpFoundation\Response;
  15. use Symfony\Component\HttpFoundation\Request;
  16. use Symfony\Component\Routing\Annotation\Route;
  17. use Symfony\Component\Filesystem\Filesystem;
  18. use Psr\Log\LoggerInterface;
  19. use App\Service\D4SeoService;
  20. use App\Service\D4SeoReturns;
  21. use App\Service\CommonService;
  22. use App\Repository\Seo\FPTasksRepository;
  24. class SEOTasksController extends AbstractController
  25. {
  26.     public $logger;
  27.     public $d4seo;
  28.     public $d4return;
  29.     public $seoinfoLogger;
  30.     protected $d4SeoService;
  31.     protected $d4SeoReturns;
  33.     function __construct(CommonService $commonService, D4SeoService $d4SeoService, D4SeoReturns $d4SeoReturns, LoggerInterface $logger,  LoggerInterface $seoinfoLogger, EntityManagerInterface $em) {
  35.         if(!strstr($_SERVER['REQUEST_URI'], '/d4return/') && !strstr($_SERVER['REQUEST_URI'], '/d4sheet/')) {
  36.             $custInfo = $commonService->custInfo();
  37.             $this->counts = $custInfo['counts'];
  38.             $this->userinfo = $custInfo['info'];
  39.         } 
  40.         $this->seologger = $seoinfoLogger;
  41.         // FOR ERROR and CRITICAL 
  42.         // $this->seologger->error("COME INFORMATION HERE - ".__FUNCTION__." ".__LINE__);
  43.         // FOR FLOW INFORMAITON
  44.         // $this->seologger->info("WHAT WERE DOING - ".__FUNCTION__."->businessDataStoreG"); 
  46.         $this->logger = $logger;
  47.         $this->d4seo = $d4SeoService;
  48.         $this->d4return = $d4SeoReturns;
  49.         $this->entityManager = $em;
  50.     }
  52.     /**
  53.      * @Route("/seotasks", name="seotasks")
  54.      */
  55.     public function index(): Response
  56.     {
  57.         $content = json_decode($this->d4seo->getUserInfo());
  58.         $apinfo = $content->tasks[0]->result[0];
  59.         return $this->render('seo_tasks/seotasksmain.html.twig', [
  60.             'page_name' => 'SEO Tasks',
  61.             'breadcrumbs' => array('SEO Tasks' => '/seotasks', 'API Info' => '' ),
  62.             'user' => $this->userinfo,
  63.             'counts' => $this->counts,
  64.             'results' => $apinfo,
  65.         ]);
  66.     }
  68.     /**
  69.      * @Route("/seotasks/businessdata/new", name="businessdata_new", methods={"GET","POST"})
  70.      */
  71.     public function bizdatanew(Request $request): Response
  72.     {
  73.         $seoTask = new SEOTasks();
  74.         $form = $this->createForm(SEOTasksType::class, $seoTask);
  75.         $form->handleRequest($request);
  77.         if ($form->isSubmitted() && $form->isValid()) {
  78.             $request = Request::createFromGlobals();
  79.             $content = $request->request->all();
  80.             $params = (object) $content['seo_tasks'];
  81.             $taskinfo = (object) array(
  82.                 'language_code' => $params->language_code,
  83.                 'location_code' => $params->location_code,
  84.                 'keyword' => trim($params->keyword),
  85.                 'purpose' => $params->purpose,
  86.                 'device' => $params->device,
  87.                 'se_type' => 'gmbusiness',
  88.                 'priority' => 2,
  89.             );
  91.             $result = $this->d4seo->businessData($taskinfo);
  92.             $mess = $result->status;
  93.             return $this->redirectToRoute('business_data', array('message' => $mess));
  94.         }
  96.         return $this->render('seo_tasks/newgmb.html.twig', [
  97.             'seo_tasks' => $seoTask,
  98.             'form' => $form->createView(),
  99.             'page_name' => 'New Task GMB Info',
  100.             'breadcrumbs' => array('SEO Tasks' => '/seotasks', 'GMB Info' => '/seotasks/businessdata/', 'New Task' => '' ),
  101.             'user' => $this->userinfo,
  102.             'counts' => $this->counts,
  103.         ]);
  104.     }
  106.     /**
  107.      * @Route("/seotasks/businessmaps/new", name="businessmaps_new", methods={"GET","POST"})
  108.      */
  109.     public function bizmapsnew(Request $request): Response  
  110.     {
  111.         $seoTask = new SEOTasks();
  112.         $form = $this->createForm(SEOTasksType::class, $seoTask);
  113.         $form->handleRequest($request);
  115.         if ($form->isSubmitted() && $form->isValid()) {
  116.             $request = Request::createFromGlobals();
  117.             $content = $request->request->all();
  118.             $params = (object) $content['seo_tasks'];
  119.             $taskinfo = (object) array(
  120.                 'language_code' => $params->language_code,
  121.                 'location_code' => $params->location_code,
  122.                 'keyword' => trim($params->keyword),
  123.                 'purpose' => $params->purpose,
  124.                 'device' => $params->device,
  125.                 'se_type' => 'maps',
  126.                 'priority' => 2,
  127.             );
  129.             $result = $this->d4seo->businessMaps($taskinfo);
  130.             $mess = $result->status;
  131.             return $this->redirectToRoute('business_maps', array('message' => $mess));
  132.         }
  134.         return $this->render('seo_tasks/newmaps.html.twig', [
  135.             'seo_tasks' => $seoTask,
  136.             'form' => $form->createView(),
  137.             'page_name' => 'New Task GMB Maps',
  138.             'breadcrumbs' => array('SEO Tasks' => '/seotasks', 'GMB Info' => '/seotasks/businessmaps/', 'New Task' => '' ),
  139.             'user' => $this->userinfo,
  140.             'counts' => $this->counts,
  141.         ]);
  142.     }
  144.     /**
  145.      * @Route("/seotasks/businessdata", name="business_data")
  146.      * This is simply how to create a direct GMB task request. Returns business and several competitors
  147.      */
  148.     public function businessData(Request $request): Response
  149.     {
  150.         //$request = Request::createFromGlobals();
  152.         if($request->get('message')) {
  153.             $mess = $request->get('message');
  154.         } else { 
  155.             $mess = ''; 
  156.         }
  157.         return $this->render('seo_tasks/bizdata.html.twig', [
  158.             'page_name' => 'GMB Info Tasks',
  159.             'breadcrumbs' => array('SEO Tasks' => '/seotasks', 'GMB Data' => '' ),
  160.             'user' => $this->userinfo,
  161.             'counts' => $this->counts,
  162.             'message' => $mess,
  163.         ]);
  164.     }
  166.     /**
  167.      * @Route("/seotasks/businessmaps", name="business_maps")
  168.      * This is simply how to create a direct GMB task request. Returns business and several competitors
  169.      */
  170.     public function businessMaps(Request $request): Response
  171.     {
  172.         /*$postinfo = (object) array(
  173.             'language_code' => 'en',
  174.             'location_code' => '1025622',
  175.             'keyword' => 'plumbers',
  176.             'purpose' => 'discovery',
  177.             'device' => 'desktop',
  178.             'priority' => 2,
  179.         );
  181.         if(!$this->checkThirty($postinfo->keyword, $postinfo->location_code, 'maps', 'sent')) {
  182.             $taskinfo = $this->d4seo->businessMaps($postinfo);
  183.         } else {
  184.             $postinfo->status = "too soon to send";
  185.             $taskinfo = $postinfo;
  186.         }*/
  187.         if($request->get('message')) {
  188.             $mess = $request->get('message');
  189.         } else { 
  190.             $mess = ''; 
  191.         }
  193.         return $this->render('seo_tasks/bizmaps.html.twig', [
  194.             'page_name' => 'Google Maps Tasks',
  195.             'breadcrumbs' => array('SEO Tasks' => '/seotasks', 'Maps Data' => '' ),
  196.             'user' => $this->userinfo,
  197.             'counts' => $this->counts,
  198.             'message' => $mess,
  199.         ]);
  200.     }
  202.     /**
  203.      * @Route("/d4sheet/{api}/{se}/{function}/{report}/{d4taskid}/", name="seotasks_sheet", methods={"GET","POST"})
  204.      * Temporarily not in use, ignore errors.
  205.      */
  206.     public function task4sheet(string $api, string $se, string $function, string $report,  string $d4taskid): Response
  207.     {
  208.         $thispost = file_get_contents('php://input');
  209.         $this->seologger->info("Sheet Returned Result ID: ".$d4taskid." - ".$api." / ".$se." / ".$function." - ".$thispost['status_code']." ".$thispost['status_message']." ");
  210.         //dd($thispost);
  211.         
  212.         $newtaskid = $this->d4seo->getUUID();
  213.         $task = $em->getRepository(SEOTasks::class)->findOneBy(array('d4id' => $d4taskid, 'status' => 'returned'));
  214.         if (!$task) {
  215.             $taskinfo->purpose = "discovery";
  216.             $taskinfo->task_id = $newtaskid;
  217.             $taskinfo->d4id = $d4taskid;
  218.             
  219.         }
  220.            
  221.         if($postinfo->status == 'sent') {
  222.             $this->d4seo->storeTask($taskinfo);
  223.         }
  225.         $postinfo->task_id = $task_id;
  226.         $taskback = (object) json_decode($content);
  227.         $taskback = $taskback->tasks[0];
  228.         $postinfo->d4id = $taskback->id;
  229.         $postinfo->api = $taskback->data->api;
  230.         $postinfo->function = $taskback->data->function;
  231.         $postinfo->se = $taskback->data->se;
  232.         $postinfo->se_type = 'gmbusiness';
  233.         $postinfo->device = $taskback->data->device;
  234.         $postinfo->os = $taskback->data->os;
  235.         if ($taskback->status_message == 'Task Created.') {
  236.             $postinfo->status = 'sent';
  237.         } else {
  238.             $postinfo->status = 'failed';
  239.         }
  240.         $postinfo->created = date('Y-m-d H:i:s');
  242.     }
  244.     /**
  245.      * @Route("/d4return/{purpose}/{api}/{se}/{function}/{task_id}/", name="seotasks_return", methods={"GET","POST"})
  246.      */
  247.     public function taskreturn(string $purpose, string $api, string $se, string $function, string $task_id): Response
  248.     {
  249.         $thispost = file_get_contents('php://input');
  250.         $em = $this->getDoctrine()->getManager();
  251.         $seotask = $em->getRepository(SEOTasks::class)->findOneBy(array('task_id' => $task_id));
  252.         if (!$seotask) {
  253.             throw $this->createNotFoundException("Task Not Found With ID: {$task_id} - ".__FUNCTION__." ".__LINE__);
  254.         } else {
  255.             $d4taskid = $seotask->getD4id();
  256.             $purpose = $seotask->getPurpose();
  257.         }
  258.         
  259.         if (!empty($thispost)) {
  260.             $postback = json_decode(gzdecode($thispost), true);
  261.             if (isset($postback['status_code'])) {
  262.                 $this->seologger->info("D4API Returned Result ID: ".$purpose."/".$d4taskid."/".$task_id." - ".$api." / ".$se." / ".$function." - ".$postback['status_code']." ".$postback['status_message']." ");
  263.             }
  264.             $d4result = $postback;  
  265.         } else {
  266.             // This is a MANUAL PULL. In other words this is check for D4Seo errors logged. It will fix lost returns.
  267.             if($function == 'my_business_info') {
  268.                 $thispost = $this->d4seo->getFetchTask('/'.$api.'/'.$se.'/'.$function.'/task_get/'.$d4taskid);
  269.             } elseif($function == 'local_pack') {
  270.                 $thispost = $this->d4seo->getFetchTask('/'.$api.'/'.$se.'/'.$function.'/task_get/regular/'.$d4taskid);
  271.             } elseif($function == 'maps') {
  272.                 $thispost = $this->d4seo->getFetchTask('/'.$api.'/'.$se.'/'.$function.'/task_get/advanced/'.$d4taskid);
  273.             } elseif($function == 'reviews') {
  274.                 $thispost = $this->d4seo->getFetchTask('/'.$api.'/'.$se.'/'.$function.'/task_get/'.$d4taskid);
  275.             } elseif($function == 'backlinkchk') {
  276.                 $thispost = $this->d4seo->getFetchTask('/'.$api.'/'.$se.'/organic/task_get/regular/'.$d4taskid);
  277.             } else {
  278.                 $thispost = $this->d4seo->getFetchTask('/'.$api.'/'.$se.'/'.$function.'/task_get/regular/'.$d4taskid);
  279.             }
  280.             
  281.             if (empty($postback)) {
  282.                 $this->seologger->info("Manual Fetch : ".$d4taskid."/".$task_id." - ".__FUNCTION__." ".__LINE__);
  283.             }
  284.             $d4result = json_decode($thispost, true);
  285.         }
  287.         if(isset($d4result['tasks'][0]['result'])) {
  288.             $d4result = $d4result['tasks'][0]['result'];
  289.         } else {
  290.             $em = $this->getDoctrine()->getManager();
  291.             $task = $em->getRepository(SEOTasks::class)->findOneBy(array('d4id' => $d4taskid));
  292.             $task->setStatus('not found');
  293.             $em->persist($task);
  294.             $em->flush();
  295.             if($purpose == 'footprint') {
  296.                 $fptask = $em->getRepository(FPTasks::class)->findOneBy(array('uuid' => $task_id));
  297.                 $fptask->setStatus('not found');
  298.                 $em->persist($fptask);
  299.                 $em->flush();
  300.                 unset($fptask);
  301.             }
  302.             unset($task);
  303.             $this->seologger->error("Returning Task : ".$d4taskid."/".$task_id." - Returned no results- ".__FUNCTION__." ".__LINE__);
  304.             return new Response();
  305.         }
  306.         
  307.         if (isset($d4result[0]['items_count']) && ($function != 'backlinkchk') ) {
  308.             if (0 == $d4result[0]['items_count']) {
  309.                 $em = $this->getDoctrine()->getManager();
  310.                 $task = $em->getRepository(SEOTasks::class)->findOneBy(array('d4id' => $d4taskid));
  311.                 $task->setStatus('not found');
  312.                 $em->persist($task);
  313.                 $em->flush();
  314.                 if($purpose == 'footprint') {
  315.                     $fptask = $em->getRepository(FPTasks::class)->findOneBy(array('uuid' => $task_id));
  316.                     $fptask->setStatus('not found');
  317.                     $em->persist($fptask);
  318.                     $em->flush();
  319.                     unset($fptask);
  320.                 }                
  321.                 unset($task);
  322.                 $this->seologger->error("Returning Task : ".$d4taskid."/".$task_id." - Returned no results - ".__FUNCTION__." ".__LINE__);
  323.                 return new Response();
  324.             }
  325.         }
  326.         
  327.         if('business_data' == $api) {
  328.             if('google' == $se) {
  329.                 if('my_business_info' == $function) 
  330.                 { $this->seologger->info("Transferring {$task_id} for {$purpose} to businessDataStoreG - ".__FUNCTION__." ".__LINE__);
  331.                   $this->businessDataStoreG($d4result, $d4taskid, $purpose); }
  332.                 elseif('my_business_updates' == $function) 
  333.                 { return new Response(); }
  334.                 elseif('reviews' == $function) 
  335.                 { $this->seologger->info("Transferring {$task_id} for {$purpose} to returningReviews - ".__FUNCTION__." ".__LINE__);
  336.                 $this->d4return->returningReviews($d4result, $d4taskid, $purpose, 'google'); }
  337.             } elseif('yelp' == $se) {
  338.                 if('reviews' == $function)
  339.                 { return new Response(); }
  340.             }
  341.         } elseif('serp' == $api) {
  342.             if('google' == $se) {
  343.                 if('organic' == $function)
  344.                 { $this->seologger->info("Transferring {$task_id} for {$purpose} to returningOrganics - ".__FUNCTION__." ".__LINE__);
  345.                   $this->d4return->returningOrganics($d4result, $d4taskid, $purpose, 'google'); }
  346.                 elseif('maps' == $function) 
  347.                 { $this->seologger->info("Transferring {$task_id} for {$purpose} to returningMapSerp - ".__FUNCTION__." ".__LINE__);
  348.                 $this->d4return->returningMapSerp($d4result, $d4taskid, $purpose, 'google'); }
  349.                 elseif('backlinkchk' == $function) 
  350.                 { $this->seologger->info("Transferring {$task_id} for {$purpose} to returningBacklinkChk - ".__FUNCTION__." ".__LINE__);
  351.                 $this->d4return->returningBacklinkChk($d4result, $d4taskid, $purpose, 'google'); }
  352.                 elseif('news' == $function) 
  353.                 { return ''; }
  354.                 elseif('images' == $function) 
  355.                 { return ''; } 
  356.             } elseif('bing' == $se) {
  357.                 if('organic' == $function)
  358.                 { $this->seologger->info("Transferring {$task_id} for {$purpose} to returningOrganics - ".__FUNCTION__." ".__LINE__);
  359.                 $this->d4return->returningOrganics($d4result, $d4taskid, $purpose, 'bing'); }
  360.                 elseif('local_pack' == $function) 
  361.                 { $this->seologger->info("Transferring {$task_id} for {$purpose} to returningMapSerp - ".__FUNCTION__." ".__LINE__);
  362.                 $this->d4return->returningMapSerp($d4result, $d4taskid, $purpose, 'bing'); }
  363.                 elseif('backlinkchk' == $function) 
  364.                 { $this->seologger->info("Transferring {$task_id} for {$purpose} to returningBacklinkChk - ".__FUNCTION__." ".__LINE__);
  365.                 $this->d4return->returningBacklinkChk($d4result, $d4taskid, $purpose, 'bing'); }
  366.             } elseif('yahoo' == $se) {
  367.                 if('organic' == $function)
  368.                 { $this->seologger->info("Transferring {$task_id} for {$purpose} to returningOrganics - ".__FUNCTION__." ".__LINE__);
  369.                 $this->d4return->returningOrganics($d4result, $d4taskid, $purpose, 'yahoo');  }
  370.             }  
  371.         } elseif('reviews' == $api) {
  372.             if('google' == $se) 
  373.                 { return ''; }
  374.             elseif('yelp' == $se) 
  375.                 { return ''; }
  376.         } elseif('keywords_data' == $api) {
  377.             if('google' == $se) {
  378.                 if('search_volume' == $function)
  379.                 { $this->d4return->returningVolumes($d4result, $d4taskid, $purpose, 'google'); }
  380.                 elseif('keywords_for_site' == $function)
  381.                 { return ''; }
  382.                 elseif('keywords_for_keywords' == $function)
  383.                 { return ''; }
  384.                 elseif('keywords_for_category' == $function)
  385.                 { return ''; }
  386.                 elseif('ad_traffic_by_keywords' == $function)
  387.                 { return ''; }
  388.                 elseif('ad_traffic_by_platforms' == $function)
  389.                 { return ''; }
  390.             } elseif('google_trends' == $se) {
  391.                 if('explore' == $function)
  392.                 { return ''; }
  393.             } elseif('bing' == $se) {
  394.                 if('search_volume' == $function)
  395.                 { return ''; }
  396.                 elseif('keywords_for_site' == $function)
  397.                 { return ''; }
  398.                 elseif('keywords_for_keywords' == $function)
  399.                 { return ''; }
  400.                 elseif('keywords_for_category' == $function)
  401.                 { return ''; }
  402.                 elseif('keyword_performance' == $function)
  403.                 { return ''; }
  404.             } 
  405.         
  406.         } elseif('merchant' == $api) {
  407.             if('google' == $se) {
  408.                 if('products' == $function)
  409.                 { return ''; }
  410.                 elseif('sellers' == $function)
  411.                 { return ''; }
  412.                 elseif('product_spec' == $function)
  413.                 { return ''; }
  414.             } elseif('amazon' == $se) {
  415.                 if('products' == $function)
  416.                 { return ''; }
  417.                 elseif('asin' == $function)
  418.                 { return ''; }
  419.             }
  420.         } elseif('on_page' == $api) {
  421.             if('ping' == $se) {
  422.                 if('back' == $function)
  423.                 { return ''; }
  424.             }
  425.         }
  426.         return new Response('Success', 200, array('Content-Type' => 'text/html'));
  427.     }
  429.     public function businessDataStoreG($d4result, $d4taskid, $purpose) {
  430.         // This guy will process and store GMB Business and GMB Map Serps
  431.         $taskready = explode('-', $d4taskid);
  432.         $itemcount = $d4result[0]['items_count'];
  433.         $keyword = $d4result[0]['keyword'];
  435.         if($itemcount >= 1 && isset($d4result[0]['items'][0]['cid']) && !empty($d4result[0]['items'][0]['title'])) 
  436.         {
  437.             $folder = 'data/gmb/'.substr($taskready[4], 0, 2);
  438.             $filename = $folder.'/'.$taskready[4].'-gmbadvanced.json';
  439.             if(!is_dir($_ENV["HOMEDIR"].'/'.$folder)) {
  440.                 mkdir($_ENV["HOMEDIR"].'/'.$folder, 0766, true );
  441.             }
  442.             if(file_exists($_ENV["HOMEDIR"].'/'.$filename)) {
  443.                 $this->seologger->info("Updating {$filename} - ".__FUNCTION__." ".__LINE__); 
  444.             } else {
  445.                 $this->seologger->info("Saving {$filename} - ".__FUNCTION__." ".__LINE__); 
  446.             }
  447.             file_put_contents($_ENV["HOMEDIR"].'/'.$filename, json_encode($d4result));
  448.             
  449.         } else {
  450.             $this->seologger->error("Task {$d4taskid} had no resulting items - ".__FUNCTION__." ".__LINE__); 
  451.             $em = $this->getDoctrine()->getManager();
  452.             $task = $em->getRepository(SEOTasks::class)->findOneBy(array('d4id' => $d4taskid));
  453.             if(isset($task)) {
  454.                 $em->remove($task);
  455.                 $this->seologger->info("Removing task {$d4taskid} - ".__FUNCTION__." ".__LINE__); 
  456.                 $em->flush();
  457.             }
  458.             $intel = $em->getRepository(IntelQueue::class)->json_like($keyword);
  459.             if(isset($intel)) {
  460.                 $em->remove($intel);
  461.                 $this->seologger->info("Removing intel queue {$keyword} - ".__FUNCTION__." ".__LINE__);
  462.                 $em->flush();
  463.             }
  464.             return;
  465.         }
  467.         $check_url = $d4result[0]['check_url'];
  468.         $location_code = $d4result[0]['location_code'];
  470.         $this->seologger->info("Keyword '{$keyword}' - ".__FUNCTION__." ".__LINE__);
  471.         foreach($d4result[0]['items'] as $item) {
  472.             $em = $this->getDoctrine()->getManager();
  473.             if(isset($item['cid'])  && $item['cid'] >= 1) {
  474.                 $place = $em->getRepository(Gplaces::class)->findOneBy(array('cid' => $item['cid']));
  475.             } else {
  476.                 $this->seologger->error("Keyword '{$keyword}' for task {$d4taskid} had no CID - ".__FUNCTION__." ".__LINE__); 
  477.                 $task = $em->getRepository(SEOTasks::class)->findOneBy(array('d4id' => $d4taskid));
  478.                 if(isset($task)) {
  479.                     $em->remove($task);
  480.                     $this->seologger->info("Removing task {$d4taskid} - ".__FUNCTION__." ".__LINE__); 
  481.                     $em->flush();
  482.                 }
  483.                 $intel = $em->getRepository(IntelQueue::class)->json_like($keyword);
  484.                 if(isset($intel)) {
  485.                     $em->remove($intel);
  486.                     $this->seologger->info("Removing intel queue {$keyword} - ".__FUNCTION__." ".__LINE__); 
  487.                     $em->flush();
  488.                 }
  489.                 break;
  490.             }
  491.             
  492.             if (!$place && isset($item['cid'])) {
  493.                 $place = new Gplaces();
  494.                 $recheck = 0;
  495.                 
  496.                 $this->seologger->info("Adding NEW Place '{$item['title']}' {$item['cid']} - ".__FUNCTION__." ".__LINE__);
  497.                 if(isset($item['latitude']) && isset($item['latitude'])) {
  498.                     $place->setLat($item['latitude']);
  499.                     $place->setLng($item['longitude']);
  500.                 } else {
  501.                     $recheck = 1;
  502.                 }
  503.                 $place->setCid($item['cid']);
  504.                 $place->setFeatureID($item['feature_id']);
  505.                 $place->setPlaceId($item['place_id']);
  506.                 if(isset($item['address'])) {
  507.                     $address_all = file_get_contents('https://maps.googleapis.com/maps/api/geocode/json?key=AIzaSyAbTq8g-XSRuqwjMltfCKf1BI-PziP_ym0&address='.urlencode($item['address']));
  508.                     if(isset($address_all)) {
  509.                         $rawaddy = json_decode($address_all, TRUE);
  510.                         if($rawaddy['status'] != 'OVER_QUERY_LIMIT' && $rawaddy['status'] != 'ZERO_RESULTS') {
  511.                             $rawaddy = $rawaddy['results'][0];
  512.                         }
  513.                     }
  514.                 }
  515.                 if($recheck == 1 && isset($item['address']) && isset($rawaddy['results'][0])) {
  516.                     if(isset($rawaddy['geometry']['location']['lat']) && isset($rawaddy['geometry']['location']['lng'])) {
  517.                         $place->setLat($rawaddy['geometry']['location']['lat']);
  518.                         $place->setLng($rawaddy['geometry']['location']['lng']);
  519.                     }
  520.                 }
  521.             } 
  523.             if(isset($rawaddy['results'][0])) {
  524.                 $place->setAddressAll($rawaddy);
  525.                 $bestlocation = $this->getLocCode($rawaddy,$location_code);
  526.             } else {
  527.                 $rawaddy = $place->getAddressAll();
  528.                 $bestlocation = $location_code;
  529.             }
  531.             $place->setKeyword($keyword);
  532.             if(!empty($item['address'])) {
  533.                 $place->setAddress($item['address']);
  534.             }
  535.             $place->setLocation($bestlocation);
  536.             if(isset($item['additional_categories'])) { 
  537.                 $place->setAddcats($item['additional_categories']);
  538.             } 
  539.             
  540.             $place->setTitle($item['title']);
  541.             $place->setPrimarycat($item['category']);
  542.             if(!empty($item['phone'])) {
  543.                 $place->setPhone($item['phone']); 
  544.             }
  545.             $place->setWorktime($item['work_time']);
  546.             if($item['url']) {
  547.                 $place->setUrl($item['url']);
  548.                 $place->setDomain($item['domain']);
  549.             }
  550.             $place->setMainImage($item['main_image']);
  551.             $place->setSnippet($item['snippet']);
  552.             if(isset($item['rating'])) {
  553.                 $place->setRatingType($item['rating']['rating_type']);
  554.                 $place->setRatingValue($item['rating']['value']);
  555.                 $place->setVotesCount($item['rating']['votes_count']);
  556.                 if(isset($item['rating']['rating_max'])) {
  557.                     $place->setRatingMax($item['rating']['rating_max']);
  558.                 }
  559.             }
  561.             $check_url = "https://www.google.com/maps?cid=".$item['cid']."&hl=en&gl=US";
  562.             $place->setCheckUrl($check_url);
  564.             if(isset($item['description'])) {
  565.                 $place->setDescription($item['description']);
  566.             }
  567.             if(isset($item['logo'])) {
  568.                 $place->setLogo($item['logo']);
  569.             }
  570.             if(isset($item['attributes'])) {
  571.                 $place->setAttributes($item['attributes']);
  572.             }
  573.             if(isset($item['people_also_search'])) {
  574.                 $place->setCompetitors($item['people_also_search']);
  575.             }
  576.             $place->setModified(\DateTime::createFromFormat('Y-m-d H:i:s', date('Y-m-d H:i:s')));
  577.             $em->persist($place);
  578.             $em->flush();
  580.             $task = $em->getRepository(SEOTasks::class)->findOneBy(array('d4id' => $d4taskid));
  581.             
  582.             $task->setStatus('returned');
  583.             $em->persist($task);
  584.             $em->flush();
  586.             if(isset($item['people_also_search'])) {
  587.                 $complist = array();
  588.                 foreach($item['people_also_search'] as $competitor)  {
  589.                     // First check if we already know about the listing via CID. If not we add the listing to the IntelQueue 
  590.                     // so tasks can be created over time. Not right away for sure. Reminder: $130 reasons why not, lol.
  591.                     $em = $this->getDoctrine()->getManager();
  593.                     if(!empty($competitor['title']) && !empty($competitor['cid'])) {
  594.                         $cid = (string) $competitor['cid'];
  595.                         $cidcheck = $em->getRepository(GPlaces::class)->doesGPlaceExist($cid);
  597.                         if (!$cidcheck) {
  598.                             $more = array(
  599.                                 'language_code' => 'en',
  600.                                 'se' => 'google',
  601.                                 'location_code' => $location_code,
  602.                                 'keyword' => $competitor['title'],
  603.                                 'cid' => $competitor['cid'],
  604.                                 'purpose' => $purpose,
  605.                             );
  606.                             $qinfo = (object) array(
  607.                                 'purpose' => $purpose,
  608.                                 'location_code' => $location_code,
  609.                                 'actionapi' => 'business_data',
  610.                                 'function' => 'my_business_info',
  611.                                 'content' =>  $competitor['title'],
  612.                                 'more' => json_encode($more),
  613.                             );
  614.                             $this->seologger->info("Storing intel queue for '{$competitor['title']}' {$competitor['cid']} - ".__FUNCTION__." ".__LINE__); 
  616.                             $this->d4seo->storeQueue($qinfo);
  617.                         }
  618.                         array_push($complist, $competitor['cid']);
  619.                     }
  620.                 }
  622.                 $cpivot = $em->getRepository(CompetitorPivot::class)->findOneBy(array('cid' => $item['cid']));
  623.                 if (!$cpivot) {
  624.                     $cpivot = new CompetitorPivot();
  625.                     $cpivot->setCid($item['cid']);
  626.                     $cpivot->setEngine('google');
  627.                 } else {
  628.                     if(is_array($cpivot->getCompCids())) {
  629.                         $complist = array_unique(array_merge($complist, json_decode($cpivot->getCompCids())), SORT_REGULAR);
  630.                     } else {
  631.                         $complist = array();
  632.                     }
  633.                 }
  634.                 $cpivot->setCompCids(json_encode($complist));
  635.                 $em->persist($cpivot);
  636.                 $em->flush();
  637.             }
  638.         }
  639.     }
  641.     private function getLocCode($addyin, $current) {
  642.         $key = 'United States';
  643.         foreach($addyin['address_components'] as $component) {
  644.             if (in_array('locality', $component['types'])) { 
  645.                 $city = $component['short_name'];
  646.             } elseif (in_array('administrative_area_level_1', $component['types'])) { 
  647.                 $state = $component['long_name'];
  648.             } elseif (in_array('postal_code', $component['types'])) { 
  649.                 $zipcode = $component['short_name'];
  650.             }
  651.         }
  652.         if (isset($city)) {
  653.             $key= $city.','; }
  654.         if (isset($state)) {
  655.             $key.= $state.','; }
  657.         $key.='United States';
  658.         $em = $this->getDoctrine()->getManager();
  659.         $location = $em->getRepository(Locations::class)->findOneBy(array('location_name' => $key));
  660.         if (!$location && $zipcode) {
  661.             $location = $em->getRepository(Locations::class)->findOneBy(array('location_name' => $zipcode.','.$state.',United States')); }
  662.         if($location) {
  663.             return $location->getLocationCode();
  664.         } else {
  665.             return $current;
  666.         }
  667.     }
  670. }