WordPress

<?php

namespace App\Controller;

use App\Entity\InvoiceItems;
use App\Entity\Model;
use App\Entity\ModelRelease;
use App\Entity\Release;
use App\Entity\Stock;
use App\Entity\StockRelease;
use App\Entity\User;
use App\Form\ModelType;
use App\Repository\InvoiceItemsRepository;
use App\Repository\ModelRepository;
use App\Repository\PayoutsRepository;
use App\Repository\ReleaseRepository;
use App\Repository\StockReleaseRepository;
use App\Repository\UserRepository;
use App\Service\SMS;
use Doctrine\ORM\EntityManager;
use Doctrine\ORM\EntityNotFoundException;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpFoundation\Session\Session;
use Symfony\Component\Routing\Annotation\Route;


use App\Util\Mailer;
use FOS\UserBundle\Model\UserManagerInterface;
use FOS\UserBundle\Util\TokenGenerator;

use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;

/**
 * @Route("/model")
 */
class ModelController extends AbstractController
{

    public $userManager;
    public $mailer;

    public function __construct(UserManagerInterface $userManager,Mailer $mailer)
    {
        $this->userManager=$userManager;
        $this->mailer=$mailer;

    }

    /**
     * @Route("/", name="model_index", methods={"GET"})
     */
    public function index(ModelRepository $modelRepository): Response
    {
        return $this->render('model/index.html.twig', [
            'models' => $modelRepository->findAll(),
        ]);
    }

    /**
     * @Route("/dashboard", name="model_dashboard", methods={"GET"})
     * @param InvoiceItemsRepository $invoiceItemsRepository
     * @param PayoutsRepository $payoutsRepository
     * @param ModelRepository $modelRepository
     * @param StockReleaseRepository $stockReleaseRepository
     * @param TokenStorageInterface $tokenStorage
     * @param Session $session
     * @return Response
     */
    public function dashboard(InvoiceItemsRepository $invoiceItemsRepository,
                              PayoutsRepository $payoutsRepository,
                              ModelRepository $modelRepository,
                              StockReleaseRepository $stockReleaseRepository,
                              TokenStorageInterface $tokenStorage,
                              Session $session): Response
    {
        /** @var User $current_user */
        $current_user = $this->getUser();
        //is current user a model??
        if(!$current_user->hasRole("ROLE_MODEL")){
            //force logout
            return $this->redirectToRoute('fos_user_security_logout');
        }
        if(empty($current_user->getModel())){
            //force logout
            return $this->redirectToRoute('fos_user_security_logout');
        }

        $em = $this->getDoctrine()->getManager();
        $conn = $em->getConnection();
        $model = $current_user->getModel();

        $models = $modelRepository->findBy(['user' => $current_user]);

        $releases = [];
        if (count($models) > 0){
            foreach ($models as $model){
                foreach ($model->getReleases() as $release){
                    $releases[] = $release;
                }
            }
        }else{
            $releases = null;
        }

        //get mys sock
        //dd($current_user->getId());
        $model_id= $current_user->getModel()->getId();
        //TODO change the way this is done
       /* $sql="select *
                from invoice_items
                where stock_id in (select the_stock_id
                                   from stock_release
                                   where the_release_id
                                             in (select id from release_form where model_id = $model_id)
                )";


        $fence_stmt = $conn->prepare( $sql );
        $fence_stmt->execute();
        $sales= $fence_stmt->fetchAll();
        $model_sales=[];
       foreach ($sales as $sale){
           $model_sales[]=$invoiceItemsRepository->find($sale['id']);
       }

       $sql2 = "select * from stock_release where the_release_id in (select id from release_form where model_id = $model_id)";
        $fence_stmt2 = $conn->prepare( $sql2 );
        $fence_stmt2->execute();
        $stock_releases = $fence_stmt2->fetchAll();

        $stockReleases = [];
        foreach ($stock_releases as $stock_release){
            $stockReleases[]=$stockReleaseRepository->find($stock_release['id']);
        }*/

        $model_sales = [];
       foreach ($models as $model){
           foreach ($invoiceItemsRepository->findModelSales($model) as $sale){
               $model_sales[] = $sale;
           }
       }

//        $stockReleases = $stockReleaseRepository->findModelReleases($model);

        $payoutsArray = [];

        /**@var  InvoiceItems $invoiceItem**/
        foreach ($model_sales 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()->getUser() === $current_user ? $modelReleases++ : null;
                }
//                $payoutPercentage = $percentage * $modelReleases / count($stockReleases);
                $payoutPercentage = $percentage;
            }else{
                $payoutPercentage = 0;
            }
            $payoutsArray[$invoiceItem->getId()] = $payoutPercentage;
        }


       //model payouts
        $payouts = $payoutsRepository->findBy(['PayoutTo'=>$model->getUser()]);

        //var_dump($sales[]);die;
        return $this->render('model/dashboard.html.twig', [
            'model' => $model,
            'releases' => $releases,
            'sales' => $model_sales,
            'payouts' => $payouts,
            'payoutPercentages' => $payoutsArray

        ]);
    }

    /**
     * @Route("/new", name="model_new", methods={"GET","POST"})
     * @param Request $request
     * @param UserRepository $userRepository
     * @param SMS $SMS
     * @param ModelRepository $modelRepository
     * @return Response
     */
    public function new(Request $request, UserRepository $userRepository,SMS $SMS,ModelRepository $modelRepository): Response
    {
        /** @var User $currentUser */
        $currentUser=$this->getUser();
        $model = new Model();
        //Create by introduces the relationship

        $model->setCreatedBy($currentUser);

        $form = $this->createForm(ModelType::class, $model);
        $form->handleRequest($request);

        if ($form->isSubmitted() && $form->isValid()) {
            //check if user exists
            $user=$this->createUser($model->getFirstName(),$model->getLastName(),$model->getEmailAddress(),$model->getPhoneNumber(),'ROLE_MODEL',$SMS);
            $modelCheck=$modelRepository->findOneBy(['user'=>$user,'createdBy'=>$currentUser]);
            if($modelCheck===null) {
//                $model = new Model();
                //Create by introduces the relationship
                $model->setCreatedBy($currentUser);
                $model->setUser($user);
                $entityManager = $this->getDoctrine()->getManager();
                $entityManager->persist($model);
                $entityManager->flush();


                ///send email notifying relationship
                $url = $this->generateUrl('model_dashboard', array(), UrlGeneratorInterface::ABSOLUTE_URL);
//                $url = $this->generateUrl('fos_user_resetting_request', array(), UrlGeneratorInterface::ABSOLUTE_URL);
                //
//                $this->mailer->sendModelRelationship($model, $url);
            }
            else{
                $model=$modelCheck;
            }
            return $this->redirectToRoute('model_show',['id'=>$model->getId()]);
        }

        return $this->render('model/new.html.twig', [
            'model' => $model,
            'form' => $form->createView(),
        ]);
    }

    /**
     * @param $fname
     * @param $lname
     * @param $email
     * @param $phone
     * @param $role
     * @return User|object|null
     */


    public function createUser($fname,$lname,$email,$phone,$role,SMS $SMS){
        $em = $this->getDoctrine()->getManager();
        $userManager=$this->userManager;
        $sendEmail=true;

        //crete a new user
        $user_roles[]=$role;
        $password =rand(10000, 99999);
        //check if exists
        $repository = $this->getDoctrine()
            ->getRepository( User::class );
        /** @var User $user */
        $user=$repository->findOneBy(['email'=>$email]);
        if($user===null) {

            //check by phumber
            $user=$repository->findOneBy(['phoneNumber'=>$phone]);

            if($user===null) {
                /** @var User $user */
                $user = $userManager->createUser();
                $user->setFirstName($fname);
                $user->setLastName($lname);
                $user->setPhoneNumber($phone);
                if($email == null){
                    $email=$phone.'@suraimages.com';
                    $user->setUsername($phone);
                    $sendEmail=false;
                }
                else{
                    $user->setUsername($email);
                }
                $user->setEmail($email);
                $user->setRoles($user_roles);
                $tokenGenerator = new TokenGenerator();
                $user->setConfirmationToken($tokenGenerator->generateToken());
                $user->setPlainPassword($password);
                $user->setEnabled(true);

                $userManager->updateUser($user, true);

                if($sendEmail) {
                    //send email
//                    $url = $this->generateUrl('fos_user_registration_confirm', array('token' => $user->getConfirmationToken()), UrlGeneratorInterface::ABSOLUTE_URL);
                    $url = $this->generateUrl('model_dashboard',[], UrlGeneratorInterface::ABSOLUTE_URL);

                    $this->mailer->sendNewUser($user, $url, $password, $this->getUser());
                }
                //send text
                $username=$user->getUsername();

                $msg="A Model account has been created by ".$this->getUser()->getFirstName()." @SuraImages".PHP_EOL."Your username is: $username ".PHP_EOL."Your password is: $password".PHP_EOL;
                /** SMS $sms */

                $SMS->send($phone,$msg);



            }else{
                if($sendEmail) {
                    $user->addRole('ROLE_MODEL');
                    $em->persist($user);
                    $em->flush();
                    $userManager->updateUser($user);
                    $url = $this->generateUrl('model_dashboard',[], UrlGeneratorInterface::ABSOLUTE_URL);

                    $this->mailer->sendExistingUserModel($user, $url, $password, $this->getUser());
                }

                //send text
                $username=$user->getUsername();

                $msg="You are now ".$this->getUser()->getFirstName()."'s model, who has added you as his/her model on Sura Images.";

                $SMS->send($phone,$msg);


            }

        }
        else{
            if($sendEmail) {
                $user->addRole('ROLE_MODEL');
                $em->persist($user);
                $em->flush();
                $userManager->updateUser($user);
                $url = $this->generateUrl('model_dashboard',[], UrlGeneratorInterface::ABSOLUTE_URL);

                $this->mailer->sendExistingUserModel($user, $url, $password, $this->getUser());
            }

            //send text
            $username=$user->getUsername();

            $msg="You are now ".$this->getUser()->getFirstName()."'s model, who has added you as his/her model on Sura Images.";

            $SMS->send($phone,$msg);
        }

        return $user;

    }

    /**
     * @Route("/{id}", name="model_show", methods={"GET"})
     * @param Model $model
     * @return Response
     */
    public function show(Model $model): Response
    {
        $releases = $model->getModelReleases();

        foreach ($releases as $release){

            try {
                if(!is_null($release->getTheRelease()->getTitle())){
                   //
                }
            } catch (EntityNotFoundException $e) {
                $this->getDoctrine()->getManager()->remove($release);
                $this->getDoctrine()->getManager()->flush();
            }

        }
        return $this->render('model/show.html.twig', [
            'model' => $model,
        ]);
    }

    /**
     * @Route("/add-release/{id}", name="model_add_release", methods={"GET", "POST"})
     * @param Model $model
     * @param Request $request
     * @param ReleaseRepository $releaseRepository
     * @return Response
     */
    public function addRelease(Model $model, Request $request, ReleaseRepository $releaseRepository): Response
    {

        if($request->isMethod('post'))
        {
          $release = $releaseRepository->find($request->get('release'));

          $model_release = new ModelRelease();

          //dump($model); die;

          $model_release->setModel($model);

          $model_release->setTheRelease($release);

          $model_release->setModelPivot($model);


          $entityManager = $this->getDoctrine()->getManager();
          $entityManager->persist($model_release);
          $entityManager->flush();

          return $this->redirectToRoute('model_show',['id'=>$model->getId()]);


        }

        $currentUser = $this->getUser();
        $cont_releases = $releaseRepository->findBy(['createBy'=>$currentUser]);
        return $this->render('model/add_release.html.twig', [
            'model' => $model,
            'cont_releases' => $cont_releases
        ]);
    }

    /**
     * @Route("/{id}/edit", name="model_edit", methods={"GET","POST"})
     */
    public function edit(Request $request, Model $model): Response
    {
        $form = $this->createForm(ModelType::class, $model);
        $form->handleRequest($request);

        if ($form->isSubmitted() && $form->isValid()) {
            $this->getDoctrine()->getManager()->flush();

            return $this->redirectToRoute('model_show', [
                'id' => $model->getId(),
            ]);
        }

        return $this->render('model/edit.html.twig', [
            'model' => $model,
            'form' => $form->createView(),
        ]);
    }

    /**
     * @Route("/{id}", name="model_delete", methods={"DELETE"})
     */
    public function delete(Request $request, Model $model): Response
    {
        if ($this->isCsrfTokenValid('delete'.$model->getId(), $request->request->get('_token'))) {
            $entityManager = $this->getDoctrine()->getManager();
            $entityManager->remove($model);
            $entityManager->flush();
        }

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

    /**
     * @Route("/release/{id}/stock", name="view_stock", methods={"GET"})
     * @param Request $request
     * @param Release $release
     * @return Response
     */
    public function viewStock(Request $request, Release $release): Response
    {
        $stockModels = $release->getStockReleases();
        return $this->redirectToRoute("model_dashboard");
        /*return $this->render('model/release_stock.html.twig', [
            'release' => $release,
            'stock_models' => $stockModels
        ]);*/

    }

    /**
     * @Route("/model/{releaseId}", name="disassociate")
     */
    public function disassociateRelease(Request $request, $releaseId)
    {

        $em = $this->getDoctrine()->getManager();
        $releasesRepo = $em->getRepository(Release::class);
        $release = $releasesRepo->findOneBy(['id'=>$releaseId]);
        $release->setModel(new Model());
        $modelId = $request->request->get('modelId');
        $model=$this->getDoctrine()->getRepository(Model::class)->findOneBy(['id'=>$modelId]);
        $model->removeRelease($release);
        dump($model);

                /*$em->persist($model);
                $em->flush();*/

        return $this->render('contributor/index.html.twig');
    }
}