WordPress

<?php

namespace App\Controller;

use App\Entity\FtpUser;
use App\Entity\Invoice;
use App\Entity\InvoiceItems;
use App\Entity\Page;
use App\Entity\Stock;
use App\Entity\StockRelease;
use App\Entity\User;
use App\Repository\CartItemRepository;
use App\Repository\InvoiceItemsRepository;
use App\Repository\PageRepository;
use App\Repository\PayoutDetailsRepository;
use App\Repository\StockRecentViewsRepository;
use App\Repository\StockRepository;
use App\Repository\ReleaseRepository;
use App\Repository\StockCategoryRepository;
//use App\Repository\StockRepository;
use App\Repository\StockTypeRepository;
use App\Repository\UserRepository;
use App\Service\FtpHelper;
use App\Service\Helper;
use App\Service\ImageHelper;
use App\Service\SMS;
use App\Service\VideoHelper;
use App\Util\Mailer;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\Finder\Finder;
use Symfony\Component\Finder\SplFileInfo;
use Symfony\Component\HttpFoundation\File\File;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;


class   AdministratorController extends AbstractController
{
    /**
     * @Route("/administrator", name="admin_dashboard")
     * @param UserRepository $userRepository
     * @param StockTypeRepository $stockTypeRepository
     * @param StockRepository $stockRepository
     * @param InvoiceItemsRepository $invoiceItemsRepository
     * @return Response
     */
    public function index(UserRepository $userRepository,
                          StockTypeRepository $stockTypeRepository,
                          StockRepository $stockRepository,
                          InvoiceItemsRepository $invoiceItemsRepository)
    {

        $imageType = $stockTypeRepository->find(4);
        $videoType = $stockTypeRepository->find(5);

        $soldImages = $invoiceItemsRepository->findSoldItemsByStockType($imageType);
        $soldVideos = $invoiceItemsRepository->findSoldItemsByStockType($videoType);


        //contributors pending

        $contibutors=$userRepository->findPendingContributors();
        $stocks=$stockRepository->findAll();
        $pendingStock=$stockRepository->findContributorPending();
        /*$items=$invoiceItemsRepository->findBy([],[
            'CreatedAt' => 'DESC'
        ]);*/
        $items = $invoiceItemsRepository->fetchSalesHistory();
        $members = $userRepository->findMembers();

        return $this->render('administrator/index.html.twig', [
            'contibutors' => $contibutors,
            'stocks' => $stocks,
            'pendingStock' => $pendingStock,
            'items' => $items,
            'allPendingStockCount' => $stockRepository->count(['status'=>Stock::PENDING_STOCK]),
            'members' =>$members,

            "imageEarning" => count($soldImages) > 0 ? $soldImages[0]['total_amount'] : 0,
            "videoEarning" => count($soldVideos) > 0 ? $soldImages[0]['total_amount'] : 0,
            "imageSales" => count($soldImages) > 0 ? $soldImages[0]['sales_count'] : 0 ,
            "videoSales" =>count($soldVideos) > 0 ? $soldImages[0]['sales_count'] : 0,
            "images" => count($stockRepository->findBy(['type'=>$imageType, 'Published'=>Stock::PUBLISHED_STOCK])),
            "videos" => count($stockRepository->findBy(['type'=>$videoType, 'Published'=>Stock::PUBLISHED_STOCK])),
        ]);
    }

    private function fetchContributorsWithPendingStock()
    {
        $stockRepository = $this->getDoctrine()->getRepository(Stock::class);
        $userRepo = $this->getDoctrine()->getRepository(User::class);
        $stockPendingApproval = $stockRepository->findBy([
            //'Published' => 0,
            'status' => Stock::PENDING_STOCK
        ]);

        //dump($stockPendingApproval);die;
        $contributorsWithPendingStock = [];
        $contributorsPendingStockCount = [];

        /**
         * @var $contributor User
         */
        foreach ($stockPendingApproval as $stock) {
            $contributor = $stock->getContributor();
            if (!in_array($contributor, $contributorsWithPendingStock, true)) {
                array_push($contributorsWithPendingStock, $contributor);
            }
            $count = count($stockRepository->findBy(["contributor" => $contributor, 'status'=>Stock::PENDING_STOCK]));
            $contributorsPendingStockCount[$contributor->getId()] = $count;
        }
        return [
            'contributors' => $contributorsWithPendingStock,
            'contributorStockCount' => $contributorsPendingStockCount,
            'pendingStockCount' => count($stockPendingApproval)
        ];
    }

    /**
     * @Route("/administrator/stock/pending", name="all_pending_stock")
     */
    public function getAllPendingStock(UserRepository $userRepository, StockRepository $stockRepository)
    {
        $contibutorsPendingStock=$stockRepository->findContributorPending();

        return $this->render("administrator/all_pending_stock.html.twig", [
            'pendingStocks' => $contibutorsPendingStock,
            'allPendingStockCount' => $stockRepository->count(['status' => Stock::PENDING_STOCK])
        ]);
    }

    /**
     * @Route("/administrator/images/{id}/approve", name="images_approve")
     * @param Request $request
     * @param $id
     * @param StockRepository $stockRepository
     * @param StockCategoryRepository $categoryRepository
     * @param ReleaseRepository $releaseRepository
     * @param StockTypeRepository $stockTypeRepository
     * @return Response
     */
    public function imagesApprovePage(Request $request,
                                     $id,
                                     UserRepository $userRepository,
                                     StockRepository $stockRepository,
                                     StockCategoryRepository $categoryRepository,
                                     ReleaseRepository $releaseRepository,
                                     StockTypeRepository $stockTypeRepository): Response
    {
        $user = $userRepository->findOneBy(['id' => $id]);
        $categories = $categoryRepository->findAll();
        $storage_dir = $this->getParameter('ftp_directory');

        $entityManager = $this->getDoctrine()->getManager();
        $currentUser = $this->getUser();
        $imageExtensions = ["jpg", "JPG", "jpeg", "png", "PNG"];
        $imageType = $stockTypeRepository->findOneBy(['title' => 'photo']);

        $releases = $releaseRepository->findBy(['createBy' => $user]);
        //$reviewedStock = $stockRepository->findBy(['contributor' => $user, 'Published' => 1]);
        $reviewedStock = $stockRepository->findBy(['contributor' => $user ,'type'=>$imageType, 'status' => Stock::APPROVED_STOCK]);

//        $pendingStock = $stockRepository->findBy(['contributor' => $user, 'Published' => 0, 'status'=>0]);

        $pendingStock = $stockRepository->findBy(['contributor' => $user,'type'=>$imageType, 'status' => Stock::PENDING_STOCK]);
        $uploads = array();

        return $this->render('administrator/images_approve.html.twig', [
            'contributor' => $user,
            'uploads' => $uploads,
            'reviewedStock' => $reviewedStock,
            'pendingStock' => $pendingStock,
            'categories' => $categories,
            'releases' => $releases,
            'stockTypes' => $stockTypeRepository->findAll()
        ]);
    }
    /**
     * @Route("/administrator/videos/{id}/approve", name="videos_approve")
     * @param Request $request
     * @param $id
     * @param StockRepository $stockRepository
     * @param StockCategoryRepository $categoryRepository
     * @param ReleaseRepository $releaseRepository
     * @param StockTypeRepository $stockTypeRepository
     * @return Response
     */
    public function videosApprovePage(Request $request,
                                      $id,
                                      UserRepository $userRepository,
                                      StockRepository $stockRepository,
                                      StockCategoryRepository $categoryRepository,
                                      ReleaseRepository $releaseRepository,
                                      StockTypeRepository $stockTypeRepository): Response
    {
        $user = $userRepository->findOneBy(['id' => $id]);
        $categories = $categoryRepository->findAll();
        $videoType = $stockTypeRepository->findOneBy(['title' => 'video']);

        $releases = $releaseRepository->findBy(['createBy' => $user]);
        $reviewedStock = $stockRepository->findBy(['contributor' => $user ,'type'=>$videoType, 'status' => Stock::APPROVED_STOCK]);
        $pendingStock = $stockRepository->findBy(['contributor' => $user,'type'=>$videoType, 'status' => Stock::PENDING_STOCK]);
        $uploads = array();

        return $this->render('administrator/videos_approve.html.twig', [
            'contributor' => $user,
            'uploads' => $uploads,
            'reviewedStock' => $reviewedStock,
            'pendingStock' => $pendingStock,
            'categories' => $categories,
            'releases' => $releases,
            'stockTypes' => $stockTypeRepository->findAll()
        ]);
    }

    /**
     * @Route("/administrator/single-stock", name="single_stock_details")
     * @param Request $request
     * @param StockRepository $stockRepository
     * @param ImageHelper $imageHelper
     * @param VideoHelper $videoHelper
     * @return JsonResponse
     */
    public function singleStockDetails(Request $request,
                                       StockRepository $stockRepository,
                                       ImageHelper $imageHelper,
                                       VideoHelper $videoHelper)
    {
        $id = $request->request->get("id");

        if (isset($id) && !empty($id)){
            $stock = $stockRepository->findOneBy([
                'id' => $id
            ]);

            $height = $stock->getType()->getTitle() == "video" ? null : $stock->getFileHeight();
            $width = $stock->getType()->getTitle() == "video" ? null : $stock->getFileWidth();
            $orientation = $height <= $width ? "landscape":"portrait";

            if($stock->getType()->getTitle() == "video"){
                $orientation = $stock->getOrientation();
            }

            $releasesKeys = $stock->getStockReleases()->getKeys();
            $releasesFiles = [];
            $newPercentage = 0;

            if (count($stock->getStockReleases()) > 0){
                $newPercentage = $stock->getStockReleases()[0]->getPercentage() ? $stock->getStockReleases()[0]->getPercentage() : "0";
            }

            $releasesFileNames = [];
            if (count($releasesKeys ) > 0 ){
                $rels = $stock->getStockReleases()->getValues();
                /**@var StockRelease $rel **/

                foreach ($rels as $rel){
                    array_push($releasesFiles,$rel->getTheRelease()->getFileName()  );
                    $relTitle = $rel->getTheRelease()->getTitle();
                    $model = $rel->getTheRelease()->getModel()->getFirstName();
                    $percentage = $rel->getTheRelease()->getPayoutPercent();
                    $releaseName_Pay = $relTitle."[".$model."]"/*."[".$percentage."%]"*/;
                    array_push($releasesFileNames, $releaseName_Pay );
                }
                //dump($releasesFiles);die;
            }

            $categories = [];
            $real_categories = [];
            if($stock->getStocksCats()!=null) {
                foreach ($stock->getStocksCats() as $stocksCat) {
                    array_push($categories, $stocksCat->getCategoryStockCat()->getId());
                    array_push($real_categories, $stocksCat->getCategoryStockCat()->getName());
                }
            }

            $imageDPI=null;
            $duration=null;
            //check dpi for image
            if ($stock->getType()->getId() == 4){
                $largeFilePath = $stock->getLargeImagePath();
                if (is_file($largeFilePath)){
                    $exifs = $imageHelper->fetchImageInfo($largeFilePath)['exifs'];
                    $xResolution = isset($exifs['XResolution']) ? $exifs['XResolution']:" ";
                    $resolutionAr = explode("/",strval($xResolution));
                    if($xResolution != " "){
                        $imageDPI = $resolutionAr[0]/$resolutionAr[1];
                    }else{
                        $imageDPI = " ";
                    }

                }
            }else{
                //for video check length
                $filePath = $stock->getFilePath();
                if (is_file($filePath)){
                    $duration = $videoHelper->fetchVideoDuration($filePath);
                }
            }

            return new JsonResponse([
                "id" => $id,
                "title" => $stock->getTitle(),
                "keywords" => $stock->getKeywords(),
                "price" => $stock->getPriceLarge(),
               /* "categories" => $stock->getCategory()->getId(),
                "real_categories" => $stock->getCategory()->getName(),*/
                "categories" => $categories,
                "real_categories" => $real_categories,
                "releases" => $releasesKeys,
                "newPercentage" => $newPercentage,
                "releaseFiles" => $releasesFiles,
                "releaseFileNames" => $releasesFileNames,
                //"imageType" => $stock->getType()->getTitle(),
                "imageType" => $stock->getImageType(),
                "imageSubType" => $stock->getImageSubType(),
                "orientation" => $orientation,
                "shootCode" => $stock->getSameShootCode(),
                "people" => $stock->getPeopleNo(),
                "reject_reason" => $stock->getRejectReason(),
                "resolution" => $stock->getVideoResolution() ? $stock->getVideoResolution() : null,
                "duration" => $stock->getVideoDuration() ?? null,
                "fps" => $stock->getVideoFps() ?? null,
                "videoType" => $stock->getVideoType(),
                "imageDPI" => $imageDPI,
                "videoDuration" => $duration
            ]);
        }
        return new JsonResponse(["error"=>true]);

    }

    /**
     * @Route("/pricing", name="pricing")
     */
    public function pricing()
    {
        return $this->render('administrator/index.html.twig', [
            'controller_name' => 'AdministratorController',
        ]);
    }

    /**
     * Royalty Free
     * @Route("/pricing/rf", name="pricing_rf")
     */
    public function pricing_rf()
    {
        return $this->render('administrator/index.html.twig', [
            'controller_name' => 'AdministratorController',
        ]);
    }

    /**
     * Contributor Profile Admin
     * @Route("/administrator/{id}/make_ftp", name="administrator_make_ftp")
     * @param User $user
     * @param FtpHelper $ftpHelper
     * @return Response
     */
    public function make_ftp(User $user,
                                FtpHelper $ftpHelper
                               )
    {
        echo '1';
        $sm = $ftpHelper->createFTP($user);
        dump($sm);
        return new Response(0);


    }
    /**
     * Contributor Profile Admin
     * @Route("/administrator/{id}/contributor", name="administrator_contributor")
     * @param User $user
     * @param StockRepository $stockRepository
     * @param StockTypeRepository $stockTypeRepository
     * @param InvoiceItemsRepository $invoiceItemsRepository
     * @return Response
     */
    public function contributor(User $user,
                                StockRepository $stockRepository,
                                StockTypeRepository $stockTypeRepository,
                                InvoiceItemsRepository $invoiceItemsRepository)
    {
        //get recent purchases
        $recentPurchases = $invoiceItemsRepository->findByContributor($user);
        //get most viewed
        $mostViewed = $stockRepository->findBy(['contributor'=>$user, 'Published'=>Stock::PUBLISHED_STOCK], ['views'=>'DESC']);

        $imageSalesInfo = $invoiceItemsRepository->findContributorEarningByType($user, $stockTypeRepository->find(4)) ?
                            $invoiceItemsRepository->findContributorEarningByType($user, $stockTypeRepository->find(4))[0] : null;
        $videoSalesInfo = $invoiceItemsRepository->findContributorEarningByType($user, $stockTypeRepository->find(5)) ?
                            $invoiceItemsRepository->findContributorEarningByType($user, $stockTypeRepository->find(5))[0] : null;

        $imageSales = $imageSalesInfo ? $imageSalesInfo['sales'] : 0;
        $imageEarning = $imageSalesInfo ? $imageSalesInfo['amount'] * 0.6 : 0;

        $videoSales = $videoSalesInfo ? $videoSalesInfo['sales'] : 0;
        $videoEarning = $videoSalesInfo ? $videoSalesInfo['amount'] * 0.6 : 0;

        $imageCount = $stockRepository->countContributorsApprovedStock($user, $stockTypeRepository->find(4));
        $videoCount = $stockRepository->countContributorsApprovedStock($user, $stockTypeRepository->find(5));



        return $this->render('administrator/contributor_profile.html.twig', [
            'user' => $user,
            'invoices' => $recentPurchases,
            "mostViewed" => $mostViewed,
            "imageEarning" => $imageEarning,
            "videoEarning" => $videoEarning,
            "imageSales" => $imageSales,
            "videoSales" =>$videoSales,
            "images" => $imageCount,
            "videos" => $videoCount
        ]);
    }

    /**
     * Contributor Profile Admin
     * @Route("/contributor_profile", name="contributor_profile")
     */
    public function contributor_profile()
    {
        return $this->render('administrator/contributor_profile.html.twig', [
            'controller_name' => 'AdministratorController',
        ]);
    }

    /**
     * Rights Ready
     * @Route("/pricing/rr", name="pricing_rr")
     */
    public function pricing_rr()
    {
        return $this->render('administrator/index.html.twig', [
            'controller_name' => 'AdministratorController',
        ]);
    }

    /**
     * @Route("/pricing/exclusive", name="pricing_exclusive")
     */
    public function pricing_exclusive()
    {
        return $this->render('administrator/index.html.twig', [
            'controller_name' => 'AdministratorController',
        ]);
    }

    /**
     * Rights Managed
     * @Route("/pricing/rm", name="pricing_rm")
     */
    public function pricing_rm()
    {
        return $this->render('administrator/index.html.twig', [
            'controller_name' => 'AdministratorController',
        ]);
    }

    /**
     * @Route("/account/edit", name="account_edit")
     */
    public function account_edit()
    {
        return $this->render('administrator/index.html.twig', [
            'controller_name' => 'AdministratorController',
        ]);
    }

    /**
     * @Route("/account/password", name="account_password")
     */
    public function account_password()
    {
        return $this->render('administrator/index.html.twig', [
            'controller_name' => 'AdministratorController',
        ]);
    }

    /**
     * @Route("/administrator/members", name="all_members")
     */
    public function members(UserRepository $userRepository)
    {
        $members = $userRepository->findMembers();
        return $this->render('administrator/members.html.twig', [
            'controller_name' => 'AdministratorController',
            'members' => $members,
        ]);
    }

    /**
     * @Route("/contributors", name="contributors")
     */
    public function contributors()
    {
        return $this->render('administrator/index.html.twig', [
            'controller_name' => 'AdministratorController',
        ]);
    }

    /**
     * @Route("/contributors/new", name="contributors_new")
     * @param Helper $helper
     * @param UserRepository $userRepository
     * @return Response
     */
    public function contributors_new(Helper $helper, UserRepository $userRepository)
    {
        $contibutors=$userRepository->findPendingContributors();
//        $new = $helper->getPendingContributors();
        return $this->render('administrator/contributors_new.html.twig', [
            'controller_name' => 'AdministratorController',
            'contributors' => $contibutors
        ]);
    }

    /**
     * @Route("/contributors/existing", name="contributors_existing")
     */
    public function contributors_existing(UserRepository $userRepository)
    {
        $existing = $userRepository->findExistingContributors();

        return $this->render('administrator/contributors.html.twig', [
            'controller_name' => 'AdministratorController',
            'contributors' => $existing
        ]);
    }

    /**
     * @Route("/contributors/total", name="contributors_total")
     */
    public function contributors_total()
    {
        return $this->render('administrator/index.html.twig', [
            'controller_name' => 'AdministratorController',
        ]);
    }

    /**
     * @Route("/contributors/resources", name="contributors_resources")
     */
    public function contributors_resources()
    {
        return $this->render('administrator/index.html.twig', [
            'controller_name' => 'AdministratorController',
        ]);
    }

    /**
     * @Route("/sales", name="sales")
     */
    public function sales()
    {
        return $this->render('administrator/index.html.twig', [
            'controller_name' => 'AdministratorController',
        ]);
    }

    /**
     * @Route("/administrator/member/{id}", name="member_show")
     * @param User $user
     * @return Response
     */
    public function member_show(User $user)
    {
        $avatar = $user->getAvatar();

        $is_url = false;

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

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

        return $this->render("administrator/member_show.html.twig",[
            'member'=>$user,
            'avatar_is_url' => $is_url
        ]);
    }

    /**
     * @Route("/administrator/invoice/{id}", name="invoice_details")
     * @param Invoice $invoice
     * @return Response
     */
    public function invoice_details(Invoice $invoice)
    {
        return $this->render('administrator/invoice_details.html.twig',[
            'invoice' => $invoice
        ]);
    }

    /**
     * @Route("/administrator/all_purchases", name="all_sales")
     * @param InvoiceItemsRepository $invoiceItemsRepository
     * @return Response
     */
    public function all_purchases(InvoiceItemsRepository $invoiceItemsRepository)
    {
        /*$soldItems=$invoiceItemsRepository->findBy([],[
            'CreatedAt' => 'DESC'
        ]);*/
        $soldItems = $invoiceItemsRepository->fetchSalesHistory();
        return $this->render('administrator/all_sales.html.twig', [
            'soldItems'=>$soldItems
        ]);
    }

    /**
     * @Route("/administrator/{name}/page", name="show_page")
     */
    public function page(PageRepository $pageRepository, $name)
    {
        $page = $pageRepository->findOneBySlug($name);

        if ($page == null){
            //create page
            return $this->redirectToRoute('page_new');
        }


        return $this->render('administrator/show_page.html.twig', [
            'page'=>$page
        ]);
    }

    /**
     * @Route("/contributor/{id}/make/exclusive", name="make_exclusive")
     */
    public function makeContributorExclusive(Request $request, User $user)
    {
        $exclusive = $request->request->get('exclusive');
        $flag = $exclusive == "true" ? 1 : 0;
        $user->setIsExclusive($flag);
        $em = $this->getDoctrine()->getManager();
        $em->persist($user);
        $em->flush();
        return new JsonResponse(['success' => $flag]);
    }

    /**
     * @Route("/administrator/{id}/approve", name="contributor_approve")
     * @param User $user
     * @param Mailer $mailer
     * @return \Symfony\Component\HttpFoundation\RedirectResponse
     * @throws \Exception
     */
    public function approve_contributor(User $user, Mailer $mailer)
    {
        $currentUser = $this->getUser();
        $em = $this->getDoctrine()->getManager();

        $user->setRegistrationComplete(1);
//        $user->setIdentityVerified(1);
        $user->setIdentityVerified(User::IDENTITY_VERIFIED);
        $user->setApprover($this->getUser());
        $user->setApprovedAt(new \DateTime());
        $em->persist($user);
        $em->flush();

        $url = $this->generateUrl('contributor_dashboard',[],UrlGeneratorInterface::ABSOLUTE_URL);

        $mailer->sendContributorApproved($user,$url, $user->getEmail());

        return $this->redirectToRoute('images_approve',[
            "id" => $user->getId()
        ]);
    }

    /**
     * @Route("/administrator/reject", name="contributor_reject")
     * @param Request $request
     * @param UserRepository $userRepository
     * @param Mailer $mailer
     * @return \Symfony\Component\HttpFoundation\RedirectResponse
     * @throws \Exception
     */
    public function rejectContributor(Request $request, UserRepository $userRepository, Mailer $mailer, SMS $SMS,PayoutDetailsRepository $payoutDetailsRepository)
    {
        $em = $this->getDoctrine()->getManager();

        if (isset($_POST['contributor_id']) && !empty($_POST['contributor_id'])){
            /** @var \App\Entity\User $user */
            $user = $userRepository->find($_POST['contributor_id']);
            $reasons = $_POST['contributor_reason'];

            $user->setRegistrationComplete(0);
            $user->setIdentityVerified(User::IDENTITY_REJECTED);
            $user->setRejectReason($reasons);
            $user->setRejectedBy($this->getUser());
            $user->setRejectedAt(new \DateTime());
            $em->persist($user);
            $em->flush();

            $url = $this->generateUrl('contributor_dashboard',[],UrlGeneratorInterface::ABSOLUTE_URL);
            $mailer->sendContributorRejected($user,$url, $reasons,$user->getEmail());
            //send sms
            $message = "Dear ".$user->getUsername().", Sorry. The identification document you uploaded has been rejected because of the following reasons:".$reasons;
            $payoutDets = $payoutDetailsRepository->findOneBy(["user" => $user]);
            if(!empty($payoutDets)){
                $SMS->send($payoutDets->getPhoneNumber(), $message);
            }
            if ($request->isXmlHttpRequest()){
                return new JsonResponse(["message" => 1]);
            }
        }

        return $this->redirectToRoute('contributors_new');
    }

    /**
     * @param User $user
     * @param InvoiceItemsRepository $invoiceItemsRepository
     * @Route("/administrator/{id}/all_sales", name="contributor_sales")
     * @return Response
     */
    public function contributor_all_sales(User $user, InvoiceItemsRepository $invoiceItemsRepository)
    {
        $soldItems=$invoiceItemsRepository->findByContributor($user);
        return $this->render('administrator/all_contributor_sales.html.twig',[
            'soldItems' => $soldItems,
            'contributor' => $user
        ]);
    }

    /**
     * @param User $user
     * @param StockRepository $stockRepository
     * @Route("/administrator/{id}/all_uploads", name="contributor_uploads")
     * @return Response
     */
    public function contributor_all_uploads(User $user, StockRepository $stockRepository)
    {
        $allStock = $stockRepository->findBy(['contributor'=>$user, 'Published'=>Stock::PUBLISHED_STOCK], ['views'=>'DESC']);
        return $this->render("administrator/all_contributor_uploads.html.twig",[
            'allStock' => $allStock,
            'contributor' => $user
        ]);
    }

    /**
     * @Route("/administrator/total-uploads", name="total_uploads")
     */
    public function totalUploads(StockRepository $stockRepository)
    {
        $allUploads = $stockRepository->findBy([
            'Published' => Stock::PUBLISHED_STOCK
        ],['createAt' => 'DESC']);
        return $this->render('administrator/total_uploads.html.twig',[
            'stocks' => $allUploads
        ]);
    }

    /**
     * @Route("/administrator/{id}/edit", name="edit_single_stock")
     */
    public function edit_single_image(Request $request, Stock $stock)
    {
        $title = $request->request->get('title');
        $keywords = $request->request->get('keywords');
        $price = $request->request->get('price');
        $hibernate = $request->request->get('hibernate');

        if (isset($title) && !empty($title)
            && isset($keywords) && !empty($keywords)
            && isset($price) && !empty($price)
        )
        {
            if ($hibernate){
                try{
                    $start = new \DateTime($request->request->get('start'));
                    $end = new \DateTime($request->request->get('end'));

                    if ($stock->getHibernated()){
                        $stock->setHibernateStartCloned($start);
                        $stock->setHibernateEndCloned($end);
                    }else{
                        $stock->setHibernateStart($start);
                        $stock->setHibernateEnd($end);
                    }
                    $stock->setHibernated(true);
                }catch (\Exception $e){
                    $this->addFlash("edit_error", "Error setting hibernate time: ".$e->getMessage());
                    return $this->render('administrator/single_image.html.twig',[
                        'image' => $stock
                    ]);
                }


            }else{
                //unhibernate file
                $stock->setHibernated(false);
            }
            $stock->setKeywords($keywords);
            $stock->setTitle($title);
            $stock->setPriceLarge($this->round_price($price));
            $stock->setPrice($this->round_price($price/2));
            $stock->setPriceSmall($this->round_price($price/3));
            $em = $this->getDoctrine()->getManager();
            $em->persist($stock);
            $em->flush();
            return $this->redirectToRoute('total_uploads');
        }

        if ($stock->getType()->getTitle() == "video"){
            return $this->render('administrator/single_video.html.twig',[
                'image' => $stock
            ]);
        }

        return $this->render('administrator/single_image.html.twig',[
            'image' => $stock
        ]);
    }

    public function round_price($price)
    {
        return round($price,2,PHP_ROUND_HALF_DOWN);
    }

    /**
     * @Route("/administrator/{id}/featured", name="featured_single_stock")
     */
    public function featured_single_stock(Request $request, Stock $stock,StockCategoryRepository $stockCategoryRepository)
    {
        $cats=$stockCategoryRepository->findAll();

        $cats =$stock->getStocksCats();

        $category = $request->request->get('category');

        if (isset($category) )
        {
            $em = $this->getDoctrine()->getManager();
            $featuredCats = $stockCategoryRepository->findBy(['featuredStock' => $stock]);
//            dd(count($featuredCats));
            if (count($featuredCats) > 0){
                foreach ($featuredCats as $featuredCat){
                    $featuredCat->setFeaturedStock(NULL);
                    $em->persist($featuredCat);
                    $em->flush();
                }
            }
            $cat=$stockCategoryRepository->find($category);
            $cat->setFeaturedStock($stock);

            $em->persist($cat);
            $em->flush();
            return $this->redirectToRoute('total_uploads');
        }
        return $this->render('administrator/featured.html.twig',[
            'image' => $stock,
            'cats' => $cats,
        ]);
    }

    public function toggleHibernate(Stock $stock)
    {
        return new Response(0);
    }

    /**
     * @Route("/{id}/delete", name="admin_delete_upload")
     * @param Stock $stock
     * @param StockController $stockController
     * @param CartItemRepository $cartItemRepository
     * @param InvoiceItemsRepository $invoiceItemsRepository
     * @return \Symfony\Component\HttpFoundation\RedirectResponse
     */
    public function delete_file(Stock $stock,
                                StockController $stockController,
                                CartItemRepository $cartItemRepository,
                                StockRecentViewsRepository $stockRecentViewsRepository,
                                InvoiceItemsRepository $invoiceItemsRepository,
                                StockCategoryRepository $categoryRepository)
    {
        $filePath=$this->getParameter('stock_directory');
        $file = is_file($stock->getFilePath()) ? new File($stock->getFilePath()) : null;
        $em = $this->getDoctrine()->getManager();

        $releases = $stock->getStockReleases();

        //check if in invoice
        $invoiceItems = $invoiceItemsRepository->findBy(['Stock' => $stock]);
        if(count($invoiceItems) > 0){
            $this->addFlash("delete_message", "The stock cannot be deleted because it is in a member's invoice. This will be useful when tracking transactions.");
            return $this->redirectToRoute("total_uploads");
        }

        //check if in cart
        $cartItems = $cartItemRepository->findBy(['Stock' => $stock]);
        foreach ($cartItems as $cartItem){
            $cart = $cartItem->getCart();
            $cart_item_amount = $cartItem->getAmount();
            $cart->setTotal($cart->getTotal() - $cart_item_amount);
            $em->persist($cart);
            $em->remove($cartItem);
        }

        foreach ($releases as $release){
            $em->remove($release);
        }
        //get the thumbnail $ preview & del
        $prevFileName = $stock->getPreviewName();
        $thumbFileName = $stock->getThumbName();
        $smImgPath = $stock->getSmallImagePath();
        $lgImgPath = $stock->getLargeImagePath();

        $smImg = is_file($smImgPath) ? new File($smImgPath): null;
        $lgImg = is_file($lgImgPath) ? new File($lgImgPath): null;
        $prevFile = is_file($prevFileName) ? new File($filePath.DIRECTORY_SEPARATOR.$prevFileName): null;
        $thumbFile = is_file($thumbFileName) ? new File($filePath.DIRECTORY_SEPARATOR.$thumbFileName): null;

        $stockController->removeFile($smImg);
        $stockController->removeFile($lgImg);
        $stockController->removeFile($prevFile);
        $stockController->removeFile($thumbFile);
        $stockController->removeFile($file);

        //check if in invoice
        $invoiceItems = $invoiceItemsRepository->findBy(['Stock' => $stock]);
        if(count($invoiceItems) > 0){
            $this->addFlash("delete_message", "The stock cannot be deleted because it is in a member's invoice. This will be useful when tracking transactions.");
            return new Response(0);
        }

        //check if in cart
        $cartItems = $cartItemRepository->findBy(['Stock' => $stock]);
        foreach ($cartItems as $cartItem){
            $cart = $cartItem->getCart();
            $cart_item_amount = $cartItem->getAmount();
            $cart->setTotal($cart->getTotal() - $cart_item_amount);
            $em->persist($cart);
            $em->remove($cartItem);
        }

        //check if is featured in StockCategory
        $categories = $categoryRepository->findBy(['featuredStock' => $stock]);
        foreach ($categories as $category){
            $category->setFeaturedStock(null);
            $em->persist($category);
        }

        //check categories in stockcats
        $stockCats = $stock->getStocksCats();
        foreach ($stockCats as $stockCat){
            $em->remove($stockCat);
        }

        //check in recent views
        $recentViews = $stockRecentViewsRepository->findBy(['stock'=>$stock]);
        foreach ($recentViews as $recentView){
            $em->remove($recentView);
        }

        $em->remove($stock);
        $em->flush();

        $this->addFlash("delete_message", "The stock has been deleted successfully.");

        return $this->redirectToRoute("total_uploads");

    }

    /**
     * @Route("/{id}/member/suspend", name="suspend_member")
     */
    public function suspend_member(Request $request, User $user, Mailer $mailer)
    {
        $em=$this->getDoctrine()->getManager();
        if ($user->getSuspendedMember()){
            $user->setSuspendedMember(false);
            $user->setSuspensionReason(null);
            $em->persist($user);
            $this->addFlash("message", "Member activated successfully.");
        }else{
            $user->setSuspendedMember(true);
            $reason = $request->request->get("suspension_reason");
            $user->setSuspensionReason($reason);
            $em->persist($user);

            $this->addFlash("message", "Member suspended successfully.");
        }

        $em->flush();

        //send mail
        $url = $this->generateUrl('membershp_membership_index',[],UrlGeneratorInterface::ABSOLUTE_URL);
        $mailer->sendMemberSuspended($user, $url);

        return $this->redirectToRoute("member_show",[
            'id' => $user->getId()
        ]);
    }

    /**
     * @Route("/{id}/contributor/suspend", name="suspend_contributor")
     * @param Request $request
     * @param User $user
     * @param Mailer $mailer
     * @return \Symfony\Component\HttpFoundation\RedirectResponse
     */
    public function suspend_contributor(Request $request,  StockRepository $stockRepository, User $user, Mailer $mailer)
    {
        $em=$this->getDoctrine()->getManager();

        if ($user->getSuspendedMember()){
            $user->setSuspendedMember(false);
            $user->setSuspensionReason(null);

            $contributor_stock = $stockRepository->findBy(['contributor'=> $user]);

            if(sizeof($contributor_stock)>0)
            {
                foreach ($contributor_stock as $stock)
                {
                    $stock->setContributorSuspended(false);
                    $em->persist($stock);
                    $em->flush();
                }
            }

            $em->persist($user);
            $this->addFlash("message", "Contributor activated successfully.");

        }else{
            $user->setSuspendedMember(true);
            $reason = $request->request->get("suspension_reason");
            $user->setSuspensionReason($reason);
            $contributor_stock = $stockRepository->findBy(['contributor'=> $user]);

            if(sizeof($contributor_stock)>0)
            {
                foreach ($contributor_stock as $stock)
                {
                    $stock->setContributorSuspended(true);
                    $em->persist($stock);
                    $em->flush();
                }
            }

            $em->persist($user);
            $em->flush();

            $this->addFlash("message", "Contributor suspended successfully.");
        }
        $url = $this->generateUrl('contributor_dashboard',[],UrlGeneratorInterface::ABSOLUTE_URL);
        $mailer->sendContributorSuspended($user, $url);

        $em->flush();

        return $this->redirectToRoute("administrator_contributor",[
            'id' => $user->getId()
        ]);
    }

    /**
     * @Route("/administrator/sales-history", name="sales_history_admin")
     */
    public function salesHistory(InvoiceItemsRepository $invoiceItemsRepository, StockRepository $stockRepository)
    {

        $paidItems = $invoiceItemsRepository->fetchSalesHistory();
        $totalSales = 0;

        foreach ($paidItems as $item){
            $totalSales += $item->getAmount();
        }


        return $this->render('administrator/sales_history.html.twig', [
            'soldItems' => $paidItems,
            'totalSales' => $totalSales,
//            'stocks' => $stocks
        ]);
    }

    /**
     * @Route("/sales-history-filter", name="sales_history_filter_admin")
     */
    public function sale_history_filter(InvoiceItemsRepository $invoiceItemsRepository, StockRepository $stockRepository, StockTypeRepository $stockTypeRepository)
    {
        if (isset($_POST['stock_id'])){
            //search by stock ID
            $stock = $stockRepository->find($_POST['stock_id']);
            $paidItems = $invoiceItemsRepository->fetchSalesForStock($stock);
            $totalSales = 0;
            foreach ($paidItems as $item){
                $totalSales += $item->getAmount();
            }

            return new JsonResponse([
                'html' => $this->renderView('administrator/_sales_history_filter_template.html.twig', [
                    'soldItems' => $paidItems,
                    'totalSales' => $totalSales,
                ]),
                'soldItems' => $paidItems,
                'total_sales' => $totalSales,
            ]);

        }

        if (isset($_POST["date_from"])){
            //Between
            $from = $_POST["date_from"];
            $to = $_POST["date_to"];

            $invoiceItemsByRange = $invoiceItemsRepository->findSalesBetweenDatesAdmin($from, $to);
            $totalSales = 0;

            /**@var $item InvoiceItems**/
            foreach ($invoiceItemsByRange as $item){
                $totalSales += $item->getAmount();
            }

            return new JsonResponse([
                'html' => $this->renderView('administrator/_sales_history_filter_template.html.twig',[
                    'soldItems' => $invoiceItemsByRange,
                    'totalSales' => $totalSales,
                ]),
                'soldItems' => $invoiceItemsByRange,
                'total_sales' => $totalSales,
            ]);

        }

        if(isset($_POST["statement"])){
            //by month
            $month = $_POST["statement"];
            $invoiceItemsOfMonth = $invoiceItemsRepository->findPaidInvoicesForMonth($month);

            $totalSales = 0;
            /**@var InvoiceItems $invoiceItem**/
            foreach ($invoiceItemsOfMonth as $invoiceItem){
                $totalSales +=$invoiceItem->getAmount();
            }

            return new JsonResponse([
                'html' => $this->renderView('administrator/_sales_history_filter_template.html.twig', [
                    'soldItems' => $invoiceItemsOfMonth,
                    'totalSales' => $totalSales
                ]),
                'soldItems' => $invoiceItemsOfMonth,
                'total_sales' => $totalSales,
            ]);
        }

        if(isset($_POST["licence_type"])){
            //search by stock Licence
            $invoiceItemsPerLicense = $invoiceItemsRepository->findSalesByLicanseAdmin($_POST['licence_type']);

            $totalSales = 0;
            /**@var InvoiceItems $invoiceItem**/
            foreach ($invoiceItemsPerLicense as $invoiceItem){
                $totalSales +=$invoiceItem->getAmount();
            }

            return new JsonResponse([
                'html' => $this->renderView('administrator/_sales_history_filter_template.html.twig', [
                    'soldItems' => $invoiceItemsPerLicense,
                    'totalSales' => $totalSales
                ]),
                'soldItems' => $invoiceItemsPerLicense,
                'total_sales' => $totalSales,
            ]);
        }

        if(isset($_POST["my_files"])){
            //Search By stock type
            $type = $stockTypeRepository->findOneBy(['title' => $_POST["my_files"]]);

            $invoiceItemsByType = $invoiceItemsRepository->findSalesByStockTypeAdmin($type);

            $totalSales = 0;
            /**@var InvoiceItems $invoiceItem**/
            foreach ($invoiceItemsByType as $invoiceItem){
                $totalSales +=$invoiceItem->getAmount();
            }

            return new JsonResponse([
                'html' => $this->renderView('administrator/_sales_history_filter_template.html.twig', [
                    'soldItems' => $invoiceItemsByType,
                    'totalSales' => $totalSales
                ]),
                'soldItems' => $invoiceItemsByType,
                'total_sales' => $totalSales,
            ]);
        }
    }

    /**
     * @Route("/financials/payouts", name="admin_payouts")
     * @param User $user
     * @return Response
     */
    public function administratorPayouts(InvoiceItemsRepository $invoiceItemsRepository,ReleaseRepository $releaseRepository){


        $contributors = $invoiceItemsRepository->fetchContributorsWithSoldItems();
        $items = $invoiceItemsRepository->findAdminPaidInvoices();
        $total = $invoiceItemsRepository->findAdminTotalPaidInvoices();

        return $this->render('administrator/payouts.html.twig',[
            'soldItems' => $items,
            'totalSales' => 0.6 * $total,
            'contributors' =>$contributors
        ]);

    }

    /**
     * @Route("/payouts/filter/admin", name="payouts_filter_admin")
     */
    public function payouts_filter(InvoiceItemsRepository $invoiceItemsRepo, UserRepository $userRepository)
    {
        $contributor = $_POST['contributor'];
        $month = $_POST['month'];

        $contributors = [];
        $items = 0;
        $total = 0;
        if (!empty($month)){
            $contributorIds = $invoiceItemsRepo->findContributorSoldInMonthAdmin($month);
            foreach ($contributorIds as $contributorId){
                $contrib = $userRepository->find($contributorId['contributor_id']);
                !in_array($contrib->getId(), $contributors, true)
                    ? $contributors[$contrib->getId()] = $contrib->getFullName()
                    : null;
            }
        }

        $selected_contributor = null;

        if (!empty($contributor) && !empty($month)){
            $selected_contributor = $userRepository->find($contributor);
            $items = $invoiceItemsRepo->findContributorPaidInvoicesForMonthAdmin($userRepository->find($contributor), $month);
            $total = $invoiceItemsRepo->findContributorTotalPaidInvoicesForMonthAdmin($userRepository->find($contributor), $month);
        }else{

            if (!empty($contributor)){
                $selected_contributor = $userRepository->find($contributor);
                $items = $invoiceItemsRepo->findContributorPaidInvoicesForAdmin($userRepository->find($contributor));
                $total = $invoiceItemsRepo->findContributorTotalPaidInvoicesAdmin($userRepository->find($contributor));
                foreach ($invoiceItemsRepo->fetchContributorsWithSoldItems() as $contributor){

                    $user = $userRepository->find($contributor['contributor_id']);
                    !in_array($user->getId(), $contributors, true)
                        ? $contributors[$user->getId()] = $user->getFullName()
                        : null;
                }



            }
            if (!empty($month)){
                $items = $invoiceItemsRepo->findPaidInvoicesForMonthAdmin($month);
                $total = $invoiceItemsRepo->findTotalPaidInvoicesForMonthAdmin($month);
            }
        }

        return new JsonResponse([
            "html"=>$this->renderView("administrator/_payouts_filter_template_admin.html.twig",[
                'soldItems' => $items,
                'totalSales' => 0.6 * $total,
                'selected_contributor' => $selected_contributor,
            ]),
            'contributors' => json_encode($contributors)
        ]);
    }

    /**
     * @Route("/{user}/exclusive-agreement", name="set_exclusive_agreement")
     */
    public function set_exclusive_agreement(Request $request,User $user, Mailer $mailer)
    {
        $em = $this->getDoctrine()->getManager();
        $exclusive_agreement = $request->request->get("exclusive_agreement");
        $exclusive_reason = $request->request->get("exclusive_reason");

        $user->setIsExclusive($exclusive_agreement);
        if (isset($exclusive_reason) && !empty($exclusive_reason)){
            //set reason
            $user->setExclusiveTermination($exclusive_reason);
        }

        $em->persist($user);
        $em->flush();

        $url = $this->generateUrl('contributor_dashboard',[],UrlGeneratorInterface::ABSOLUTE_URL);
        try {
            $mailer->sendExclusiveLicenceContract($url,$user);
        }catch (\Exception $exception){
            //
        }

        $this->addFlash("message","Contributor exclusive contract updated successfully");
        return $this->redirectToRoute("administrator_contributor",[
            'id' => $user->getId()
        ]);
    }
}