WordPress

<?php
/**
 * Created by PhpStorm.
 * User: komu
 * Date: 17/04/19
 * Time: 22:10
 */

namespace App\Service;


use App\Entity\CartItem;
use App\Entity\Invoice;
use App\Entity\InvoiceItems;
use App\Entity\Page;
use App\Entity\Payment;
use App\Entity\Release;
use App\Entity\Resource;
use App\Entity\RoyaltyFreePricing;
use App\Entity\SearchAnalysis;
use App\Entity\Spectralsample;
use App\Entity\Stock;
use App\Entity\StockCategory;
use App\Entity\StockType;
use App\Entity\User;
use App\Repository\RoyaltyFreePricingRepository;
use App\Repository\SearchAnalysisRepository;
use App\Repository\StockTypeRepository;
use App\Repository\UserRepository;
use Doctrine\ORM\EntityManager;
use Doctrine\ORM\NonUniqueResultException;
use Doctrine\ORM\NoResultException;
use Symfony\Component\Finder\SplFileInfo;
use Symfony\Component\HttpFoundation\File\File;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
use Symfony\Component\Routing\Router;

class Helper
{
    private $em;
    private $router;
    private $root_dir;
    private $imageHelper;

    public function __construct( EntityManager $em ,Router $router,$root_dir, ImageHelper $imageHelper) {
        $this->em    = $em;
        $this->router    = $router;
        $this->root_dir    = $root_dir;
        $this->imageHelper = $imageHelper;
    }

    public function countPendingStock(User $user) {
        $repository = $this->em->getRepository( Stock::class );
        $criteria   = ['contributor'=>$user,'Published'=>0];
        return $repository->count( $criteria );
    }

    /**
     * @param $file SplFileInfo
     */
    public function getFileUrl($file){

        $relativePath=str_replace( $this->root_dir ,'',$file->getRealPath());
//        echo $this->root_dir;
        return $relativePath;
    }
    /**
     * @param $file SplFileInfo
     */
    public function getPendingImgFileUrl($file){
        $relativePath=str_replace( $this->root_dir ,'',$file->getRealPath());
        $thumb_folder = Stock::IMAGE_THUMBS_DIR;
        return str_replace("/$thumb_folder/","/",$relativePath);
    }

    /**
     * @param $file SplFileInfo
     */
    public function getVideoFileUrl($file){
        $relativePath=str_replace( $this->root_dir ,'',$file->getRealPath());
        return str_replace(".gif",".mp4",$relativePath);
    }
    public function countReviewedStock(User $user) {
        $repository = $this->em->getRepository( Stock::class );
        $criteria   = ['contributor'=>$user,'Published'=>1];
        return $repository->count( $criteria );
    }


    public function amountByStatus($status='PENDING',$user_id=false) {
        $conn = $this->em->getConnection();
        $sql  = "SELECT sum(total) as total_amount FROM invoice WHERE status like '$status'";
        if($user_id)
            $sql.=" AND create_by_id= $user_id";


        $stmt = $conn->prepare( $sql );
        $stmt->execute();

        return ( $stmt->fetch()['total_amount'] );
    }
    public function getPages() {
        $conn = $this->em->getConnection();
        $sql  = "SELECT * FROM page";


        $stmt = $conn->prepare( $sql );
        $stmt->execute();

        return ( $stmt->fetchAll() );
    }
    public function getTermsPage() {
        $conn = $this->em->getConnection();
        /** @var Page $page */
        $page = $this->em->getRepository( Page::class )
            ->find(1);

        return $page;
    }
    public function getResources() {
        $conn = $this->em->getConnection();
        /** @var Page $page */
        $resources = $this->em->getRepository( Resource::class )
            ->findAll();

        return $resources;
    }
    public function checkRelease($id) {
        $release = $this->em->getRepository( Release::class )
            ->find($id);

       if($release){
           if($release->getFileName()){
               return true;
           }

       }
       return false;
    }

    public function getPrivacyPage() {
        $conn = $this->em->getConnection();
        /** @var Page $page */
        $page = $this->em->getRepository( Page::class )
            ->find(2);

        return $page;
    }

    /**
     * @param Spectralsample $spectralsample
     */
    public function generatePDF( Payment $payment ) {
//        $logger         = $this->get( 'monolog.logger.komu' );
        $em=$this->em;
        $report_date= new \DateTime();

        $preview_url = $this->router->generate('receipt_payment', array('id' =>$payment->getId()), UrlGeneratorInterface::ABSOLUTE_URL);
        $file_name=$payment->getAuthCode().'receipt.pdf';
        $file_path='uploads/receipt/'.$file_name;
        $cmd="wkhtmltopdf  ";
        $cmd.=" --lowquality ";
        $cmd.="-R 0 -L 0 -T 40 -B 40  --dpi 100  --no-outline --viewport-size 1440x960 $preview_url $file_path";
        //save to db

//        $logger->addInfo( 'running command ' . $cmd,array('controller'=>'internalReport','function'=>'generatePDF ') );
        file_put_contents( "wkhtmltopdf.log", print_r( $cmd, true ) );


        exec( $cmd );

    }

    public function getInvoiceTotal ($items)
    {
        $total = 0;

        foreach ($items as $item)
        {
            $total+= (int) $item->total;

        }
        return $total;
    }

    /**
     * @param SplFileInfo $videoFile
     * @return mixed
     */
    public function getVideoGif($videoFile)
    {
        $realPath = $videoFile->getRealPath();
        $root_dir = $this->root_dir;
        $gifFile = str_replace($root_dir, '', $realPath);
        $gifFile = str_replace("mp4", "gif",$gifFile);
        //echo $gifFile;
        return $gifFile;
    }


    public function getAllStockTypes()
    {
        $stockTypeRepo = $this->em->getRepository(StockType::class);
        return $stockTypeRepo->findAll();
    }

    public function getStockCategoryCount(StockCategory $category)
    {
        $stockRepo = $this->em->getRepository(Stock::class);
        return count($stockRepo->findBy(['category'=>$category]));
    }

    public function getLastUploadPending($id)
    {
        $stockRepo = $this->em->getRepository(Stock::class);
        $user= $this->em->getRepository(User::class)->find($id);
        $stock = $stockRepo->findOneBy([
//            'Published'=>0,
            'status'=>Stock::PENDING_STOCK,
            'contributor' => $user
        ]);

        return $stock->getCreateAt();
    }

    public function getMembers()
    {
        $role = 'ROLE_MEMBER';
        $qb = $this->em->createQueryBuilder();
        $qb->select('u')
            ->from(User::class, 'u')
            ->where('u.roles LIKE :roles')
            ->orderBy('u.id', 'DESC')
            ->setParameter('roles', '%"'.$role.'"%');
        return $qb->getQuery()->getResult();
    }

    public function getAdmins()
    {
        $role = User::SUB_ADMINS;
        $qb = $this->em->createQueryBuilder();
        $qb->select('u')
            ->from(User::class, 'u')
            ->where('u.roles LIKE :roles')
            ->orderBy('u.id', 'DESC')
            ->setParameter('roles', '%"'.$role.'"%');
        return $qb->getQuery()->getResult();
    }

    public function getActiveContributors()
    {
        $role = 'ROLE_CONTRIBUTOR';

        $qb = $this->em->createQueryBuilder();
        $qb->select("COUNT(u.id)")
            ->from(User::class, 'u' )
            ->where('u.IdentityVerified = :idVerify')
            ->andWhere('u.roles LIKE :role')
            ->setParameter('idVerify', User::IDENTITY_VERIFIED)
            ->setParameter('role', '%"'.$role.'"%');

        try {
            return $qb->getQuery()->getSingleScalarResult();
        } catch (NoResultException $e) {
            return 0;
        } catch (NonUniqueResultException $e) {
            return 0;
        }
    }

    //////For searchfilter sidebar///////////////

    public function fetchApprovedContributors()
    {
        $role='ROLE_CONTRIBUTOR';
        $qb = $this->em->createQueryBuilder();
        $qb->select('u')
            ->from(User::class, 'u')
            ->where('u.roles LIKE :roles')
            ->andWhere('u.IdentityVerified = :IdVerify')
//            ->setMaxResults(5)
            ->orderBy('u.id ','DESC')
            ->setParameter('IdVerify',User::IDENTITY_VERIFIED)
            ->setParameter('roles', '%"' . $role . '"%');
        return $qb->getQuery()->getResult();
    }

    ////////////////////////////////////////////

    public function getPendingContributors()
    {
        $role = 'ROLE_CONTRIBUTOR';

        $qb = $this->em->createQueryBuilder();
        $qb->select("COUNT(u.id)")
            ->from(User::class, 'u' )
            ->where('u.IdentityVerified = :idVerify')
            ->andWhere('u.roles LIKE :role')
            ->setParameter('idVerify', User::IDENTITY_UPLOADED)
            ->setParameter('role', '%"'.$role.'"%');

        try {
            return $qb->getQuery()->getSingleScalarResult();
        } catch (NoResultException $e) {
            return 0;
        } catch (NonUniqueResultException $e) {
            return 0;
        }
    }

    public function getTotalUploads()
    {
        $qb = $this->em->createQueryBuilder();
        $qb->select("COUNT(s.id)")
            ->from(Stock::class, 's')
            ->where('s.Published = :published')
            ->setParameter('published', Stock::PUBLISHED_STOCK);
        try {
            return $qb->getQuery()->getSingleScalarResult();
        } catch (NoResultException $e) {
            return 0;
        } catch (NonUniqueResultException $e) {
            return 0;
        }
    }
    public function getAllContributors(){
        $role = 'ROLE_CONTRIBUTOR';
        $qb = $this->em->createQueryBuilder();
        $qb->select('COUNT(u.id)')
            ->from(User::class, 'u')
            ->where('u.roles LIKE :role')
            ->andWhere('u.IdentityVerified > :idVerify')
            ->setParameter('idVerify', User::IDENTITY_NOT_UPLOADED)
            ->setParameter('role', '%"'.$role.'"%');
        try {
            return $qb->getQuery()->getSingleScalarResult();
        } catch (NoResultException $e) {
            return 0;
        } catch (NonUniqueResultException $e) {
            return 0;
        }
    }

    public function getWeekSales( ) {
        $conn = $this->em->getConnection();
        $sql  = "SELECT x.dt as sale_date,
      IFNULL(sum(v.total),0) as total_sale
    FROM (SELECT DATE_SUB(CURRENT_DATE, INTERVAL (n.id - 1) DAY) AS dt
          FROM numbers n
          WHERE n.id <= 7 ) x
             LEFT JOIN invoice v ON DATE((v.create_time)) = DATE(x.dt)
    GROUP BY x.dt
    ORDER BY x.dt";
        $stmt = $conn->prepare( $sql );
        $stmt->execute();
        $result = $stmt->fetchAll();

        return ( $result );
    }
    public function getWeekDates( ) {
        $conn = $this->em->getConnection();
        $sql  = "SELECT DATE_SUB(CURRENT_DATE, INTERVAL (n.id - 1) DAY) AS dt
FROM numbers n
WHERE n.id <= 7 ORDER BY  id DESC ";
        $stmt = $conn->prepare( $sql );
        $stmt->execute();
        $result = $stmt->fetchAll();

        return ( $result );
    }

    //search analysis
    public function getSearchedWords()
    {
        $sql = "SELECT * FROM `search_analysis` ORDER BY created_at DESC";
        $conn = $this->em->getConnection();
        $stmt = $conn->prepare( $sql );
        $stmt->execute();
        $result = $stmt->fetchAll();
        return ( $result );
    }

    public function getSearchedWordsForMonth($date)
    {
        try{
            $date = new \DateTime($date);
        }catch (\Exception $e){
            //
        }

        $sql = "SELECT * FROM `search_analysis` WHERE created_at BETWEEN :start AND :end ORDER BY created_at DESC";
        $conn = $this->em->getConnection();
        $stmt = $conn->prepare( $sql );
        $stmt->bindValue("start", $date->format("Y-m-d"));
        $stmt->bindValue("end", $date->format("Y-m-t"));
        $stmt->execute();
        $result = $stmt->fetchAll();
        return ( $result );
    }
    
    //Enforce pricing on upload form
//    public function getPricing()
//    {
//        $royaltyFreeRepo = $this->em->getRepository(RoyaltyFreePricing::class);
//        //$criteria = []
//        /** @var $pricing RoyaltyFreePricing **/
//        $pricing = $royaltyFreeRepo->findBy([],[],1)[0];
//        return $pricing;
//    }

    public function getPricingByType($title)
    {
        $typeRepo = $this->em->getRepository(StockType::class);
        $type = $typeRepo->findOneBy(['title'=>$title]);

        $royaltyFreeRepo = $this->em->getRepository(RoyaltyFreePricing::class);
        //$criteria = []
        /** @var $pricing RoyaltyFreePricing **/
        $pricing = $royaltyFreeRepo->findBy(['type'=>$type],[],1)[0];
        return $pricing;
    }

    public function getCategories()
    {
        $categoriesRepo = $this->em->getRepository(StockCategory::class);
        return $categoriesRepo->findAll();
    }

    //get days since join date
    public function getDays($startDate, $endDate)
    {
        $dateDiff = $endDate - $startDate;
        return round($dateDiff / (60 * 60 * 24));
    }

    public function getImagesType()
    {
        $stockTypeRepository = $this->em->getRepository(StockType::class);
        return $stockTypeRepository->findOneBy(['title' => 'photo']);
    }

    public function getVideosType()
    {
        $stockTypeRepository = $this->em->getRepository(StockType::class);
        return $stockTypeRepository->findOneBy(['title' => 'video']);
    }

    public function getStockType($title)
    {
        $stockTypeRepository = $this->em->getRepository(StockType::class);
        return $stockTypeRepository->findOneBy(['title'=>$title]);
    }

    public function getRole($role)
    {
        $newRole = str_replace("ROLE_","", $role);
        return ucfirst(strtolower(str_replace("_", " ",$newRole)));
    }

    public function generateStocksArForModel($salesAr)
    {
        $newAr = [];
        foreach ($salesAr as $item){
            /**@var $item InvoiceItems**/
            array_push($newAr,$item->getStock()->getId());
        }
        return $newAr;
    }

    public function getTotalSalesForStock(Stock $stock)
    {
        $invoiceItemsRepo = $this->em->getRepository(InvoiceItems::class);

        return count($invoiceItemsRepo->findBy(['Stock'=>$stock]));
    }

    public function calculateSalesForRelease(Stock $stock, User $user)
    {
        $qb = $this->em->createQueryBuilder();
        try {
            $amount = $qb->select('SUM(i.Amount)')
                ->from(InvoiceItems::class, 'i')
                ->join('i.Invoice', 'inv')
                ->where('i.Stock = :stock')
                ->andWhere('inv.Status = :status')
                ->setParameter('stock', $stock)
                ->setParameter('status', Invoice::PAID)
                ->getQuery()
                ->getSingleScalarResult();

            $stockReleases = $stock->getStockReleases();
            if (count($stockReleases) > 0){
                $percentage = $stockReleases[0]->getPercentage();
                $modelReleases = 0;
                foreach ($stockReleases as $stockRelease){
//                    $stockRelease->getTheRelease()->getModel()->getUser() === $user ? $modelReleases++ : null;
                }

//                return $amount * $percentage/100 * $modelReleases/count($stockReleases) * 0.6;
                return $amount * $percentage/100 * 0.6;

            }else{
                return 0;
            }

        } catch (NoResultException $e) {
            return 0;
        } catch (NonUniqueResultException $e) {
            return 0;
        }
    }

    public function avatarIsUrl(string $avatar = null)
    {
        $is_url = false;

        if ($avatar){
            $pref = substr($avatar,0, 4);

            if ($pref == 'http'){
                $is_url = true;
            }
        }

        return $is_url;
    }


    public function getStockDetails(CartItem $cartItem)
    {
        $stock = $cartItem->getStock();
        $size = $cartItem->getSize();
        $imageHelper = $this->imageHelper;
        $stockTypeRepository = $this->em->getRepository(StockType::class);
        $width=null;
        $height=null;
        $smallWidth=null;
        $smallHeight=null;
        $largeWidth=$stock->getFileWidth();
        $largeHeight=$stock->getFileHeight();

        if (strtolower($size) == "small"){
            $file = $stock->getSmallImagePath();
        }elseif (strtolower($size) == 'medium'){
            $file = $stock->getFilePath();
        }else{
            $file = $stock->getLargeImagePath();
        }



        if (is_file($file)){
            $xResolution = $imageHelper->fetchImageInfo($file)['exifs']['XResolution'];
            $resolutionAr = explode("/",strval($xResolution));
            $resolution = $resolutionAr[0]/$resolutionAr[1];
            $fileSize = getimagesize($file);
            $width=$fileSize[0];
            $height=$fileSize[1];
            $fileObj = new File($file);
            $fileSize = number_format($fileObj->getSize()/1000000,1);
        }

        if ($stock->getType() === $stockTypeRepository->findOneBy(['title'=>'photo'])) {
            //
        }

        return [
            'width' => $width,
            'height' => $height,
            'resolution' => $resolution,
            'size' => $fileSize
        ];
    }
}