WordPress

<?php

namespace App\Controller;

use App\Entity\EmailSubscription;
use App\Entity\FtpUser;
use App\Entity\Invoice;
use App\Entity\InvoiceItems;
use App\Entity\PayoutDetails;
use App\Entity\Stock;
use App\Entity\User;
use App\Form\PayoutDetailsType;
use App\Form\StockType;
use App\Repository\EmailCategoryRepository;
use App\Repository\EmailSubscriptionRepository;
use App\Repository\FtpUserRepository;
use App\Repository\InvoiceItemsRepository;
use App\Repository\ModelRepository;
use App\Repository\PayoutDetailsRepository;
use App\Repository\ReleaseRepository;
use App\Repository\StockModelRepository;
use App\Repository\StockRepository;
use App\Repository\StockTypeRepository;
use App\Service\FileUploader;
use App\Service\SMS;
use FOS\UserBundle\Form\Factory\FactoryInterface;
use FOS\UserBundle\Model\UserManagerInterface;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\IsGranted;
use Symfony\Bundle\FrameworkBundle\Console\Application;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\Console\Input\ArrayInput;
use Symfony\Component\Console\Output\BufferedOutput;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Symfony\Component\Filesystem\Filesystem;
use Symfony\Component\Finder\Finder;
use Symfony\Component\HttpFoundation\File\UploadedFile;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpFoundation\Session\Session;
use Symfony\Component\HttpKernel\KernelInterface;
use Symfony\Component\Routing\Annotation\Route;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
use App\Util\Mailer;
use Symfony\Component\HttpFoundation\Session\SessionInterface;
use Symfony\Component\Security\Core\Authentication\Token\UsernamePasswordToken;

class ContributorController extends AbstractController
{

    private $kernel;

    /**
     * ContributorController constructor.
     * @param $kernel
     */
    public function __construct(KernelInterface $kernel)
    {
        $this->kernel = $kernel;
    }


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

    /**
     * @Route("/contributor/email", name="contributor_email")
     */
    public function contributor_email()
    {
        return $this->render('contributor/email.html.twig', [
            'controller_name' => 'ContributorController',
        ]);
    }

    /**
     * @Route("/contributor/dashboard", name="contributor_dashboard")
     * @param ModelRepository $modelRepository
     * @param ReleaseRepository $releaseRepository
     * @param InvoiceItemsRepository $invoiceItemsRepository
     * @return Response
     */
    public function contributor_dashboard(
        ModelRepository $modelRepository,
        ReleaseRepository $releaseRepository,
        StockTypeRepository $stockTypeRepository,
        InvoiceItemsRepository $invoiceItemsRepository,
        EmailCategoryRepository $emailCategoryRepository,
        EmailSubscriptionRepository $emailSubscriptionRepository,
        StockRepository $stockRepository
    )
    {

        /** @var User $currentUser */
        $currentUser = $this->getUser();

        $em = $this->getDoctrine()->getManager();

        //get & set email subs

       foreach ($emailCategoryRepository->findAll() as $emailCategory){
           if (!$emailSubscriptionRepository->findOneBy(['emailCategory'=>$emailCategory, 'User'=>$currentUser])){
               $subscription = new EmailSubscription();
               $subscription->setUser($currentUser);
               $subscription->setEmailCategory($emailCategory);
               $subscription->setStatus(false);
               $em->persist($subscription);
           }
       }

       $em->flush();

        //get recent purchases
        $purchases = $invoiceItemsRepository->findByContributor($currentUser);

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

        $soldImages = $invoiceItemsRepository->findSoldItemsByStockTypeContributor($imageType, $this->getUser());
        $soldVideos = $invoiceItemsRepository->findSoldItemsByStockTypeContributor($videoType, $this->getUser());

        //get stock earnings
        $imageEarning = count($soldImages) > 0 ? $soldImages[0]['total_amount'] * 0.6 : 0;
        $videoEarning = count($soldVideos) > 0 ? $soldVideos[0]['total_amount'] * 0.6 : 0;
        $imageSales = count($soldImages) > 0 ? $soldImages[0]['sales_count'] : 0;
        $videoSales = count($soldVideos) > 0 ? $soldVideos[0]['sales_count'] : 0;
        $images = $stockRepository->count(['type'=>$imageType, 'contributor'=>$this->getUser(), 'Published'=>Stock::PUBLISHED_STOCK]);
        $videos = $stockRepository->count(['type'=>$videoType, 'contributor'=>$this->getUser(), 'Published'=>Stock::PUBLISHED_STOCK]);



        if (!$currentUser->getPayoutDetails()) {
            return $this->redirectToRoute('contributor_contact_start');
        }
        $myModels = $modelRepository->findBy(['createdBy' => $currentUser]);
        $myReleases = $releaseRepository->findBy(['createBy' => $currentUser]);
        $soldItems = $invoiceItemsRepository->findByContributor($currentUser);
        $mostViewed = $stockRepository->findBy(['contributor' => $currentUser], ['views' => 'DESC']);
        //findContributorTotal
        $totalSales = $invoiceItemsRepository->findContributorTotal($currentUser);
        $sales = $invoiceItemsRepository->findContributorSales($currentUser);

        return $this->render('contributor/dashboard.html.twig', [
            'controller_name' => 'ContributorController',
            'currentUser' => $currentUser,
            'totalSales' => $totalSales,
            'sales' => $sales,
            'myModels' => $myModels,
            'soldItems' => $soldItems,
            'myReleases' => $myReleases,
            'mostViewed' => $mostViewed,

            "imageEarning" => $imageEarning,
            "videoEarning" => $videoEarning,
            "imageSales" => $imageSales,
            "videoSales" => $videoSales,
            "images" => $images,
            "videos" => $videos
        ]);
    }

    /**
     * @Route("/contributor/models", name="contributor_models")
     * @param ModelRepository $modelRepository
     * @return Response
     */
    public function contributor_models(ModelRepository $modelRepository)
    {
        $finder = new Finder();
        $storage_dir = $this->getParameter('ftp_directory');
        $entityManager = $this->getDoctrine()->getManager();
        $currentUser = $this->getUser();
        $myModels = $modelRepository->findBy(['createdBy' => $currentUser]);
        return $this->render('stock/models.html.twig', [
            'currentUser' => $currentUser,
            'myModels' => $myModels,


        ]);
    }

    /**
     * @Route("/contributor/models/new", name="contributor_models_new")
     */
    public function contributor_models_new()
    {
        return $this->render('contributor/email.html.twig', [
            'controller_name' => 'ContributorController',
        ]);
    }

    /**
     * @Route("/contributor/account/identification", name="contributor_identification")
     */
    public function contributor_identification()
    {
        return $this->render('contributor/identification.html.twig', [
            'controller_name' => 'ContributorController',
        ]);
    }

    /**
     * @Route("/contributor/account/ftp", name="contributor_account_ftp")
     */
    public function contributor_account_ftp(FtpUserRepository $ftpUserRepository)
    {
        $entityManager = $this->getDoctrine()->getManager();
        $currentUser = $this->getUser();
        $storage_dir = $this->getParameter('ftp_directory');
        $filesystem = new Filesystem();
        $finder = new Finder();


        /** @var User $currentUser */

        $ftpUser = $ftpUserRepository->findOneBy(['user' => $currentUser]);
        if ($ftpUser == null) {
            $ftpUser = new FtpUser();
            $ftpUser->setUser($currentUser);
            $ftpUser->setUserid($currentUser->getUsernameCanonical());

            try {
                $ftpPath = $storage_dir . '/' . $currentUser->getUsernameCanonical();

                if (!$filesystem->exists($ftpPath)) {
                    $filesystem->mkdir($ftpPath);
                }

                $ftpUser->setHomedir($ftpPath);
                $ftpUser->setPasswd(uniqid());
                $entityManager->persist($ftpUser);
                $entityManager->flush();


            } catch (IOExceptionInterface $exception) {
                echo "An error occurred while creating your directory at " . $exception->getPath();
                die;
            }
        }
        $ftpPath = $storage_dir . DIRECTORY_SEPARATOR . $currentUser->getUsernameCanonical();
        $files = $finder->files()->in($ftpPath);

        return $this->render('contributor/ftp.html.twig', [
            'ftpUser' => $ftpUser,
            'files' => $files,
            'controller_name' => 'ContributorController',
        ]);
    }


    public function createFtpDetails()
    {
        $application = new Application($this->kernel);
        $application->setAutoExit(false);

        $input = new ArrayInput(array(
            'command' => 'app:ftpuser',
            'username' => $this->getUser()->getUsername(),
            'password' => uniqid()
        ));

        $output = new BufferedOutput();

        try {
            $application->run($input, $output);
        } catch (\Exception $e) {
            dd($e->getMessage());
        }


        $content = $output->fetch();

        return new Response($content);
    }

    /**
     * @Route("/contributor/upload/image", name="contributor_upload_image")
     */
    public function contributor_upload_image()
    {
        return $this->render('contributor/upload_image.html.twig', [
            'controller_name' => 'ContributorController',
        ]);
    }

    /**
     * @Route("/contributor/account/contact", name="contributor_contact")
     * @param PayoutDetailsRepository $detailsRepository
     * @param Request $request
     * @return RedirectResponse|Response
     */
    public function contributor_contact(PayoutDetailsRepository $detailsRepository, Request $request)
    {
        $entityManager = $this->getDoctrine()->getManager();
        $currentUser = $this->getUser();

        $details = $detailsRepository->findOneBy(['user' => $currentUser]);
        if ($details === null) {
            $details = new PayoutDetails();
            $details->setUser($currentUser);
        }
        $form = $this->createForm(PayoutDetailsType::class, $details);
        $form->handleRequest($request);

        if ($form->isSubmitted() && $form->isValid()) {
            $entityManager->persist($details);
            $entityManager->flush();

            $this->addFlash('contributor_success', 'Your Payout Details Have been successfully updated.');
            //todo redirect to upload

            return $this->redirectToRoute('stock_images_upload', [

            ]);
        }
        //dump($details);die;
        return $this->render('payout_details/edit.html.twig', [
            'payout_detail' => $details,
            'form' => $form->createView(),
        ]);

    }

    /**
     * @Route("/contributor/account/identification/upload", name="contributor_identification_upload")
     * @param FileUploader $fileUploader
     * @param Request $request
     * @return RedirectResponse
     */
    public function contributor_identification_upload(FileUploader $fileUploader, Request $request)
    {
        $entityManager = $this->getDoctrine()->getManager();
        /** @var User $currentUser */
        $currentUser = $this->getUser();
        $file = $request->files->get('document');

        $upload_dir = $this->getParameter('kernel.project_dir') . '/public/uploads/contributor/identity';
        if (!is_dir($upload_dir)) {
            mkdir($upload_dir, 0777, true);
        }//remove files in the the directory
        $fileName = $fileUploader->upload($file, $upload_dir, false, null, null);
        $currentUser->setIdentityFile($fileName);
        $currentUser->setIdentityVerified(User::IDENTITY_UPLOADED);
        $entityManager->persist($currentUser);
        $entityManager->flush();


        $this->addFlash('contributor_success', 'Your identification has been uploaded and is waiting for admin approval.');

        return $this->redirectToRoute('contributor_contact_start');

    }

    /**
     * @Route("/contributor/avatar/upload", name="contributor_avatar_upload")
     * @param FileUploader $fileUploader
     * @param Request $request
     * @return JsonResponse
     */
    public function contributor_avatar_upload(FileUploader $fileUploader, Request $request)
    {
        $entityManager = $this->getDoctrine()->getManager();
        /** @var User $currentUser */
        $currentUser = $this->getUser();
        $file = $request->files->get('file');

        $upload_dir = $this->getParameter('kernel.project_dir') . '/public/uploads/avatar';
        if (!is_dir($upload_dir)) {
            mkdir($upload_dir, 0777, true);
        }//remove files in the the directory
        $fileName = $fileUploader->upload($file, $upload_dir, false, null, null);
        $currentUser->setAvatar($fileName);
        $entityManager->persist($currentUser);
        $entityManager->flush();
        //flash
        return new JsonResponse($fileName);

    }

    /**
     *
     * @Route("/contributor/start", name="contributor_start")
     * @param Mailer $mailer
     * @param TokenStorageInterface $tokenStorage
     * @param Session $session
     * @return RedirectResponse
     */
    public function contributor_start(Mailer $mailer, TokenStorageInterface $tokenStorage, Session $session)
    {
        /** @var User $currentUser */
        $currentUser = $this->getUser();
        $currentUser->addRole('ROLE_CONTRIBUTOR');
        $currentUser->setIdentityVerified(User::IDENTITY_VERIFIED);
        $entityManager = $this->getDoctrine()->getManager();
        //create ftp user
        $this->createFtpDetails();
        $entityManager->persist($currentUser);
        $entityManager->flush();

        if($currentUser->hasRole('ROLE_USER'))
        {
            $firewallName = "main";

            $user_token = new UsernamePasswordToken($currentUser, null, $firewallName, $currentUser->getRoles());

            $tokenStorage->setToken($user_token);

            // $user_token->setUser($user);

            $session->start();

            $session->set('_security_main', serialize($user_token));

            $session->save();

        }

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

        $message = (new \Swift_Message('Congratulations! You are now a Sura Images contributor'))
            ->setTo($currentUser->getEmail())
            ->setFrom(getenv('EMAIL_FROM'))
            ->setBody(
                $this->renderView(
                    'contributor/welcome_email.html.twig',
                    array(
                        'user' => $currentUser,
                        'confirmationUrl' => $url,
                    )
                ),
                'text/html'
            );

        $mailer->send($message);

        $this->addFlash('contributor_success', 'Your account has been successfully created.');

        //email
        return $this->redirectToRoute('contributor_dashboard');
    }

    /**
     * @Route("/contributor/all_uploads", name="all_image_uploads")
     * @param StockRepository $stockRepository
     * @return Response
     */
    public function all_image_uploads(StockRepository $stockRepository)
    {
        $currentUser = $this->getUser();
        $allStock = $stockRepository->findBy(['contributor' => $currentUser], ['views' => 'DESC']);
        return $this->render('contributor/all_image_uploads.html.twig', [
            'allStock' => $allStock
        ]);
    }

    /**
     * @Route("/contributor/all_purchases", name="all_purchases")
     * @param InvoiceItemsRepository $invoiceItemsRepository
     * @return Response
     */
    public function all_purchases(InvoiceItemsRepository $invoiceItemsRepository)
    {
        /**@var User $currentUser */
        $currentUser = $this->getUser();
        $soldItems = $invoiceItemsRepository->findByContributor($currentUser);
        $total = $invoiceItemsRepository->findContributorTotal($currentUser);

        return $this->render('contributor/all_purchases.html.twig', [
            'soldItems' => $soldItems,
            'total' => $total * 0.6
        ]);
    }

    /**
     * @Route("/contributor/edit/payout/verify", name="verify_edit")
     * @param PayoutDetailsRepository $payoutDetailsRepository
     * @param SMS $SMS
     * @param Mailer $mailer
     * @return RedirectResponse|Response
     */
    public function confirm_edit_payout(PayoutDetailsRepository $payoutDetailsRepository, SMS $SMS, Mailer $mailer)
    {
        /**
         * @var User $currentUser
         */
        $currentUser = $this->getUser();
        if (isset($_POST['code'])) {
            $code = $_POST['code'];

            if ($currentUser->getSecurityCode() === $code) {

                return $this->redirectToRoute("edit_contact_payout_details");
            }
            $this->addFlash("message", "Wrong code");
            return $this->render("contributor/verify_edit_payout.html.twig");
        }
        $security_code = rand(1000, 9999);
        $currentUser->setSecurityCode($security_code);
        $em = $this->getDoctrine()->getManager();
        $em->persist($currentUser);
        $em->flush();

        $text = "Your Sura verification code: " . $security_code;

        $payoutDets = $payoutDetailsRepository->findOneBy(["user" => $currentUser]);
        if ($payoutDets) {
            $phone = $payoutDets->getPhoneNumber();
            $SMS->send($phone, $text);
            $mailer->sendOTP($currentUser, $security_code);
        } else {
            if(!is_null($currentUser->getPhoneNumber())){
                $SMS->send($currentUser->getPhoneNumber(), $text);
            }

            $mailer->sendOTP($currentUser, $security_code);

        }


        return $this->render("contributor/verify_edit_payout.html.twig");
    }


    /**
     * @Route("/contributor/edit/payout/details", name="edit_contact_payout_details")
     * @param PayoutDetailsRepository $detailsRepository
     * @param Request $request
     * @return RedirectResponse|Response
     */
    public function contributor_edit_payout_details(PayoutDetailsRepository $detailsRepository, Request $request)
    {
        $currentUser = $this->getUser();
        $entityManager = $this->getDoctrine()->getManager();

        $details = $detailsRepository->findOneBy(['user' => $currentUser]);
        if ($details === null) {
            $details = new PayoutDetails();
            $details->setUser($currentUser);
        }
        $form = $this->createForm(PayoutDetailsType::class, $details);
        $form->handleRequest($request);

        if ($form->isSubmitted() && $form->isValid()) {
            $entityManager->persist($details);
            $entityManager->flush();

            //$this->addFlash('contributor_success', 'Your Payout Details Have been successfully updated.');
            //todo redirect to upload

            return $this->redirectToRoute('contributor_contact', [

            ]);
        }
        //dump($details);die;
        return $this->render('payouts/edit_contributor_payout_details.html.twig', [
            'payout_detail' => $details,
            'form' => $form->createView(),
        ]);
    }

    /**
     * @Route("/contributor/account/contact/start", name="contributor_contact_start")
     */
    public function contributor_contact_start(PayoutDetailsRepository $detailsRepository, Request $request)
    {
        $entityManager = $this->getDoctrine()->getManager();
        /** @var User $currentUser */
        $currentUser = $this->getUser();

        $details = $detailsRepository->findOneBy(['user' => $currentUser]);
        if ($details === null) {
            $details = new PayoutDetails();
            $details->setUser($currentUser);
        }
        $form = $this->createForm(PayoutDetailsType::class, $details);
        $form->handleRequest($request);

        if ($form->isSubmitted() && $form->isValid()) {
            $entityManager->persist($details);
            $currentUser->setRegistrationComplete(1);
            $entityManager->persist($currentUser);
            $entityManager->flush();

            $this->addFlash('contributor_success', 'Your Payout Details Have been successfully updated.');
            //todo redirect to upload

            return $this->redirectToRoute('stock_images_upload', [

            ]);
        }
        //dump($details);die;
        return $this->render('contributor/contact_details_start.html.twig', [
            'payout_detail' => $details,
            'form' => $form->createView(),
        ]);

    }

    /**
     * @Route("/{id}/sales-history", name="sales_history")
     */
    public function salesHistory(User $user, InvoiceItemsRepository $invoiceItemsRepository, StockRepository $stockRepository)
    {
        $stocks = $stockRepository->findBy(['contributor' => $this->getUser(), 'Published'=>Stock::PUBLISHED_STOCK]);
        //$invoiceItems = $invoiceItemsRepository->findBy(['Stock']);

        $invoiceItems = $invoiceItemsRepository->findByContributor($this->getUser());
        $totalSales = $invoiceItemsRepository->findContributorTotalPaidInvoicesAdmin($this->getUser());


        return $this->render('contributor/sales_history.html.twig', [
            'soldItems' => $invoiceItems,
            'totalSales' => $totalSales * 60 / 100,
            'stocks' => $stocks
        ]);
    }

    /**
     * @Route("/sales-history-filter-contributor", name="sales_history_filter_contributor")
     */
    public function sale_history_filter(InvoiceItemsRepository $invoiceItemsRepository, StockRepository $stockRepository, StockTypeRepository $stockTypeRepository)
    {
        $stocks = $stockRepository->findBy(['contributor' => $this->getUser(), /*'Published' => true*/]);
        if (isset($_POST['stock_id'])) {

            $paidItems = $invoiceItemsRepository->findContributorSoldStockById($stockRepository->find($_POST['stock_id']));
            $totalSales = 0;
            foreach ($paidItems as $item) {
                $totalSales += $item->getAmount();
            }

            return new JsonResponse([
                'html' => $this->renderView('contributor/_sales_history_template.html.twig', [
                    'soldItems' => $paidItems,
                    'totalSales' => $totalSales * 60 / 100,
                ]),
                'total_sales' => $totalSales,
                'soldItems' => $paidItems
            ]);

        }

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

            $invoiceItemsByRange = $invoiceItemsRepository->findSalesBetweenDates($from, $to, $this->getUser());
            $totalSales = 0;

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

            return new JsonResponse([
                'html' => $this->renderView('contributor/_sales_history_template.html.twig', [
                    'soldItems' => $invoiceItemsByRange,
                    'totalSales' => $totalSales * 60 / 100
                ]),
                'total_sales' => $totalSales,
                'soldItems' => $invoiceItemsByRange
            ]);

        }

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

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

            return new JsonResponse([
                'html' => $this->renderView('contributor/_sales_history_template.html.twig', [
                    'soldItems' => $invoiceItemsOfMonth,
                    'totalSales' => $totalSales * 60 / 100
                ]),
                'total_sales' => $totalSales,
                'soldItems' => $invoiceItemsOfMonth
            ]);
        }

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

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

            return new JsonResponse([
                'html' => $this->renderView('contributor/_sales_history_template.html.twig', [
                    'soldItems' => $invoiceItemsPerLicense,
                    'totalSales' => $totalSales * 60 / 100
                ]),
                'total_sales' => $totalSales,
                'soldItems' => $invoiceItemsPerLicense
            ]);
        }

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

            $invoiceItemsByType = $invoiceItemsRepository->findSalesByStockType($type, $this->getUser());

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

            return new JsonResponse([
                'html' => $this->renderView('contributor/_sales_history_template.html.twig', [
                    'soldItems' => $invoiceItemsByType,
                    'totalSales' => $totalSales* 60 / 100
                ]),
                'total_sales' => $totalSales,
                'soldItems' => $invoiceItemsByType
            ]);
        }
    }

    /**
     * @Route("/payouts/filter", name="payouts_filter")
     */
    public function payouts_filter(InvoiceItemsRepository $invoiceItemsRepo, ModelRepository $modelRepository)
    {
        $modelID = $_POST['model'];
        $month = $_POST['month'];

        $model = $modelRepository->find($modelID);

//        $invoiceItems = $invoiceItemsRepo->findContributorPaidInvoicesForMonth($this->getUser(), $month);
        $invoiceItems = $invoiceItemsRepo->findContributorPaidInvoicesInMonthModel($this->getUser(),$model,$month);

        $totalPayouts = 0;
        $totalOveralPercentage = 0;
        $stocksPercentagePayout = [];

        /**@var  $invoiceItem InvoiceItems**/
        foreach ($invoiceItems as $invoiceItem){
            $amount = $invoiceItem->getAmount();
            $stock = $invoiceItem->getStock();
            $stockReleases = $stock->getStockReleases();

            if (count($stockReleases) > 0 && $stockReleases[0]->getPercentage()){
                $percentage = $stockReleases[0]->getPercentage();
                $payoutPercentage = 0;
                $modelReleases = 0;
                foreach ($stockReleases as $stockRelease){
//                    $stockRelease->getTheRelease()->getModel() === $model ? $modelReleases++ : null;
                }
//                $payoutPercentage = $percentage * $modelReleases / count($stockReleases);
                $payoutPercentage = $percentage;
            }else{
                $payoutPercentage = 0;
            }

            $totalOveralPercentage += $payoutPercentage;
            $stocksPercentagePayout[$invoiceItem->getId()] = $payoutPercentage;
            $totalPayouts += $payoutPercentage/100 * 0.6 * $amount;

        }


        return new JsonResponse([
            "html" => $this->renderView("contributor/_payouts_filter_template.html.twig", [
                'soldItems' => $invoiceItems,
                'stocksPerc' => $stocksPercentagePayout,
                'totalSales' => $totalPayouts,
//                'models' => $models
            ]),

        ]);
    }

    /**
     * @Route("/my-financials/{id}/payouts", name="my_payouts")
     * @param User $user
     * @param ModelRepository $modelRepository
     * @param InvoiceItemsRepository $invoiceItemsRepository
     * @param ReleaseRepository $releaseRepository
     * @return Response
     */
    public function contributorPayouts(User $user,
                                       ModelRepository $modelRepository,
                                       InvoiceItemsRepository $invoiceItemsRepository,
                                       ReleaseRepository $releaseRepository)
    {

        $invoiceItems = $invoiceItemsRepository->findContributorPaidInvoices($this->getUser());

        $totalSales = 0;

        $stocksPercentagePayout = [];
        $totalOveralPercentage = 0;
        $totalPayouts = 0;

        /**@var $paidInvoiceItem InvoiceItems* */
        foreach ($invoiceItems as $paidInvoiceItem) {
            $totalSales += $paidInvoiceItem->getAmount();
            $stock = $paidInvoiceItem->getStock();
            $stockReleases = $stock->getStockReleases();

            $itemAmount = $paidInvoiceItem->getAmount();

            $payoutPercentage = count($stockReleases) > 0
                                ? $stockReleases[0]->getPercentage() ? $stockReleases[0]->getPercentage() : 0
                                : 0;

            $totalPayouts += $payoutPercentage/100 * 0.6 * $itemAmount;

            $stocksPercentagePayout[$paidInvoiceItem->getId()] = $payoutPercentage;
            $totalOveralPercentage += $payoutPercentage;
        }

        $modelIds = $invoiceItemsRepository->findModelsWithSoldItems($user);
        $models = [];
        foreach ($modelIds as $modelId){
            $model = $modelRepository->find($modelId['model_id']);
            !in_array($model,$models,true) ? array_push($models,$model) : null;
        }

        return $this->render('contributor/payouts.html.twig', [
            'soldItems' => $invoiceItems,
            'stocksPerc' => $stocksPercentagePayout,
            'totalPayouts' => $totalPayouts,
            'models' => $models
        ]);

    }

    /**
     * @Route("/contributor/subscription/edit", name="edit_subscription", methods={"POST"})
     */
    public function editEmailSubscription(EmailSubscriptionRepository $emailSubscriptionRepository)
    {
        $em = $this->getDoctrine()->getManager();

        /**
         * @var $currentUser User
         */
        $currentUser = $this->getUser();

        $userSubscriptions = $currentUser->getEmailSubscriptions();

        foreach ($userSubscriptions as $userSubscription){
            $em->persist($userSubscription->setStatus(false));
        }
        foreach ($_POST as $key=>$value){
            $subscrption = $emailSubscriptionRepository->find($key);
            $subscrption->setStatus(true);
            $em->persist($subscrption);
        }
        $em->flush();
        return $this->redirectToRoute("fos_user_profile_show");
    }
}