Elep

<?php

namespace App\Controller;

use App\Controller\Controller;
use Symfony\Component\Routing\Annotation\Route;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\JsonResponse;
use Doctrine\ODM\MongoDB\DocumentManager;
use App\Entity\Item;
use App\Document\Item as ItemDocument;
use App\Document\Place as PlaceDocument;
use App\Entity\ItemPart;
use App\Entity\Stock;
use App\Entity\OrderItem;
use App\Entity\SupplyItem;
use App\Service\EmailSender;
use App\Service\FileUploader;
use App\Service\MailgunTransport;
use Knp\Component\Pager\PaginatorInterface;

class InventoryController extends Controller
{

private $dm;

public function __construct(MailgunTransport $mailgun, DocumentManager $dm) {
        $this->dm = $dm;
        $this->mailgun = $mailgun;
    }

private function getPlaces(string $place_slug): array
    {
        $user = $this->getUser();
        $places = $this->dm->getRepository(PlaceDocument::class)->findBy(['owner' => $user->getEmail()]);
        $place = array_filter($places, function($pl) use ($place_slug){
            return $pl->getSlug() == $place_slug;
        });

// var_dump($place);die;

return [$places, array_values($place)[0]];
    }

/**
     * @Route("/admin/place/{place_slug}", name="profile", methods={"GET"})
     */
    public function profile(DocumentManager $dm, string $place_slug)
    {
        list($places, $place) = $this->getPlaces($place_slug);
        $place = $dm->getRepository(PlaceDocument::class)->findOneBy(['slug' => $place_slug]);

// var_dump($place);die;
        
        return $this->render('Users/profile.html.twig', ['title' => 'Profile', 'place' => $place, 'places' => $places, 'count' => count($places)]);
    }

/**
     * @Route("/admin/places/owned", name="owned")
     */
    public function owned()
    {
        $user = $this->getUser();
        $places = $this->dm->getRepository(PlaceDocument::class)->findBy(['owner' => $user->getEmail()]);
        if(count($places) === 1) {
            return $this->redirectToRoute('profile', ['place_slug' => $places[0]->getSlug()]);
        }
        
        return $this->render('Users/owned.html.twig', ['owned' => $places, 'title' => 'Owned']);
    }

/**
     * @Route("/admin/places/change", methods={"POST"}, name="change_place")
     */
    public function changePlace()
    {
        $place = $this->dm->getRepository(PlaceDocument::class)->findOneBy(['slug' => $_POST['place']]);
        return $this->redirectToRoute($_POST['route'], ['place_slug' => $_POST['place']]);
    }

/**
     * Traverse an associative array and
     * @param array $arrayInput
     * @return array
     */
    private function handleArrayInput(array $arrayInput)
    {
        try {
            $keys = array_keys($arrayInput);
            $f = array();
            for ($i=0; $i < count($arrayInput[$keys[0]]); $i++) {
                $n = array();
                foreach ($keys as $key) {
                    $n[$key] = $arrayInput[$key][$i];
                }
                $f[] = $n;
            }

return $f;
        } catch (\Exception $e) {
            
        }
    }

public function changeTimeFormat()
    {
        if(!isset($_POST['daily'])) {
            $_POST["mon"] = $_POST["tue"] = $_POST["wed"] = $_POST["thu"] = $_POST["fri"] = $_POST["sat"] = $_POST["sun"] = [];
            $_POST["mon"][0] = $_POST["tue"][0] = $_POST["wed"][0] = $_POST["thu"][0] = $_POST["fri"][0] = $_POST["sat"][0] = $_POST["sun"][0] = $_POST['opening'] ?? "";
            $_POST["mon"][1] = $_POST["tue"][1] = $_POST["wed"][1] = $_POST["thu"][1] = $_POST["fri"][1] = $_POST["sat"][1] = $_POST["sun"][1] = $_POST['closing'] ?? "";
        }

// $opening = \DateTime::createFromFormat('g:i A', $times[0])->format('H:i');
        // $close = \DateTime::createFromFormat('g:i A', $times[1])->format('H:i');
        return [
            "mon" => $_POST["mon"] ?? ["", ""],
            "tue" => $_POST["tue"] ?? ["", ""],
            "wed" => $_POST["wed"] ?? ["", ""],
            "thu" => $_POST["thu"] ?? ["", ""],
            "fri" => $_POST["fri"] ?? ["", ""],
            "sat" => $_POST["sat"] ?? ["", ""],
            "sun" => $_POST["sun"] ?? ["", ""],
        ];
    }

/**
     * @Route("/admin/place/profile/{id}", name="profileUpdate", methods={"POST"})
     * @param Request $request
     **/
    public function updateProfile(Request $request, FileUploader $fileUploader, EmailSender $sender, $id)
    {
        $user = $this->getUser();
        // var_dump($_POST['daily']);die;
        $place = $this->dm->getRepository(PlaceDocument::class)->find($id);
        if ($place) {
            
            $place->setName($_POST['name']);
            $place->setPhones($_POST['telephone']);
            $place->setAddress($_POST['address']);
            $place->setTimes($this->changeTimeFormat());
            $place->setDaily($_POST['daily'] ?? '');
            $place->setOpening(isset($_POST['daily']) ? NULL : $_POST['opening'] ?? "");
            $place->setClosing(isset($_POST['daily']) ? NULL : $_POST['closing'] ?? "");

$place->setType($_POST['type']);
            $place->setTags($_POST['tags'] ?? []);
            $place->setDelivery($_POST['delivery'] ?? []);
            $place->setDeliver($_POST['deliver'] ?? '');

$place->setLocation(array(
                "type" => "Point",
                "coordinates" => array(floatval($_POST['longitude']), floatval($_POST['latitude']))
            ));
            
            if (isset($_FILES['image'])) {
                $files = $this->handleArrayInput($_FILES['image']);
                
                if($imageFile = $fileUploader->uploadFiles($files, $place->getSlug())){
                    $place->setImage($imageFile);
                }
            }

$this->dm->persist($place);
            $this->dm->flush();

$this->addFlash(
                'success',
                sprintf('%s updated', $place->getName())
            );

$sender->sendPlainEmail('Users/notification.html.twig', 'obinna.okafor01@gmail.com', 'Profile Updated', sprintf("%s updated their profile", $place->getName()));

return $this->redirectToRoute('profile', ['place_slug' => $place->getSlug()]);
        }

return $this->render('Users/profile.html.twig', array('title' => 'Account', 'user' => $user));
    }

/**
     * @Route("/admin/place/image/delete", name="delete_place_image", methods={"POST"})
     */
    public function deletePlaceImage(Request $request)
    {
        $user = $this->getUser();
        $data = json_decode($request->getContent(), true);
        $result = $this->dm->createQueryBuilder(PlaceDocument::class)
            ->updateOne()
            ->field('image')->pull($data['url'])
            ->field('owner')->equals($user->getEmail())
            ->getQuery()
            ->execute();

if(!$num = $result->getModifiedCount()){
            return $this->json(['error' => 'image not found'], 404);
        }

return $this->json(['status' => 'OK']);
    }

/**
     * List items or show an individual item
     *
     * @param int | null $id item id
     *
     * @Route("/admin/items/{place_slug}", name="items", methods={"GET"})
     */
    public function items(PaginatorInterface $paginator, Request $request, string $place_slug)
    {
        list($places, $place) = $this->getPlaces($place_slug);

$query = $this->dm->getRepository(ItemDocument::class)->findAllPaginated($place_slug);

$items_paginated = $paginator->paginate(
            $query,
            $request->query->getInt('page', 1),
            15
        );

return $this->render('Inventory/items.html.twig', array('title' => 'Items', 'items' => $items_paginated, 'place' => $place, 'places' => $places, 'count' => count($places)));
    }

/**
     * List items or show an individual item
     *
     * @param int | null $id item id
     *
     * @Route("/admin/items/edit/{id}", name="editItem", methods={"GET"})
     */
    public function edit($id)
    {
        $user = $this->getUser()->getEmail();

$item = $this->dm->getRepository(ItemDocument::class)->findOneBy(['id' => $id, 'owner' => $user]);
        $place = $this->dm->getRepository(PlaceDocument::class)->findOneBy(['slug' => $item->getPlaceSlug()]);

return $this->render('Inventory/edititem.html.twig', array('title' => 'Edit Item', 'category' => $place->getCategory(), 'item' => $item, 'id' => $id));
    }

/**
     * @Route("/admin/items/update/{id}", name="updateItem", methods={"POST"})
     */
    public function updateItem($id)
    {
        $user = $this->getUser()->getEmail();
        $item = $this->dm->getRepository(ItemDocument::class)->findOneBy(['id' => $id, 'owner' => $user]);
        $item->setName($_POST['name']);
        $item->setPrice($_POST['selling']);
        $item->setDescription($_POST['description']);
        $item->setCategory($_POST['category']);
        $this->dm->persist($item);
        $this->dm->flush();
        
        return $this->redirectToRoute('items', ['place_slug' => $item->getPlaceSlug()]);
    }

/**
     * @Route("/admin/items/{place_slug}", name="registerItem", methods={"POST"})
     */
    public function addItem(Request $request, string $place_slug, FileUploader $fileUploader)
    {
        $user = $this->getUser();
        // $data = json_decode($request->getContent(), true);
        $place = $this->dm->getRepository(PlaceDocument::class)->findOneBy(['owner' => $user->getEmail(), 'slug' => $place_slug]);
        $data = $_POST;
        $files = isset($_FILES['image']) && $_FILES['image'] ? $this->handleArrayInput($_FILES['image']) : [];
        
        // return $this->json($data);
        for ($i=0; $i < count($data['name']); $i++) {
            $item = $this->dm->getRepository(ItemDocument::class)->findOneBy(['name' => $data['name'][$i], 'owner' => $user->getEmail(), 'place_slug' => $place_slug]);
            
            // If there is a duplicate name, check if the item was soft deleted
            if ($item && $item->getDeleted()) {
                $item->setDeleted(NULL);
            }elseif($item){
                // alert user to duplicate item name
                // return $this->json(['message' => 'Item name ' . $data['name'][$i] . ' already exists']);
            }
            else {
                // create new item
                $item = new ItemDocument;
                
                $item->setOwner($user->getEmail());
                $item->setName($data['name'][$i]);
            }
            $item->setCategory($data['category'][$i]);
            $item->setPrice($data['selling'][$i]);
            $item->setDescription($data['description'][$i]);
            $item->setPlaceSlug($place_slug);
            $item->setPlaceName($place->getName());
            if(isset($files[$i]) && $files[$i]) {
                $imageFile = $fileUploader->upload($files[$i], $place_slug);
                $item->setImg($imageFile);
            }
            
            // $item->setIcon($data['icon']);

$this->dm->persist($item);
            // $em->persist($stock);
            $this->dm->flush();
        }
        $this->dm->flush();

return $this->redirectToRoute('items', ['place_slug' => $place->getSlug()]);

// return $this->json($item, 201, ['Location' => $url]);
    }

/**
     * @Route("/admin/items/{id}/delete", name="deleteItem")
     */
    public function deleteItem($id)
    {
        $item = $this->dm->getRepository(ItemDocument::class)->find($id);
        if($item){
            $this->dm->remove($item);
            $this->dm->flush();
        }

$user = $this->getUser();
        $place = $this->dm->getRepository(PlaceDocument::class)->findOneBy(['owner' => $user->getEmail()]);

return $this->redirectToRoute('items', ['place_slug' => $place->getSlug()]);
    }

/**
     * @Route("/admin/category/{place_slug}", name="category", methods={"GET"})
     */
    public function category($place_slug)
    {
        list($places, $place) = $this->getPlaces($place_slug);
        $place = $this->dm->getRepository(PlaceDocument::class)->findOneBy(['slug' => $place_slug]);

return $this->render('Inventory/category.html.twig', [
            'title' => 'Categories',  
            'category' => '', 
            'place' => $place,
            'places' => $places,
            'count' => count($places)
        ]);
    }

/**
     * @Route("/admin/category/{place_slug}", name="addCategory", methods={"POST"})
     */
    public function updateCategory($place_slug)
    {
        $user = $this->getUser();
        // $place = $this->dm->getRepository(PlaceDocument::class)->findOneBy(['owner' => $user->getEmail()]);

// $place->setCategory($_POST['name']);
        $this->dm->createQueryBuilder(PlaceDocument::class)
            ->updateOne()
            ->field('category')->addToSet($_POST['name'])
            ->field('owner')->equals($user->getEmail())
            ->field('slug')->equals($place_slug)
            ->getQuery()
            ->execute();

// $this->dm->flush();

return $this->redirectToRoute('category', ['place_slug' => $place_slug]);
    }

/**
     * @Route("/admin/category/{place_slug}/{name}/delete", name="deleteCategory")
     */
    public function deleteCategory($place_slug, $name)
    {
        $user = $this->getUser();
        // $place = $this->dm->getRepository(PlaceDocument::class)->findOneBy(['owner' => $user->getEmail()]);
        $place = $this->dm->createQueryBuilder(PlaceDocument::class)
            ->findAndUpdate()
            ->field('category')->pull($name)
            ->field('owner')->equals($user->getEmail())
            ->field('slug')->equals($place_slug)
            ->getQuery()
            ->execute();

$items = $this->dm->createQueryBuilder(ItemDocument::class)
            ->updateMany()
            ->field('owner')->equals($user->getEmail())
            ->field('place_slug')->equals($place_slug)
            ->field('category')->equals($name)
            ->field('category')->set('')
            ->getQuery()
            ->execute();

return $this->redirectToRoute('category',['place_slug' => $place_slug]);
    }

/**
     * @Route("/admin/inventory/all", name="allinventory")
     *
     * @return JsonResponse
     **/
    public function inventory()
    {
        $user = $this->getUser()->getId();
        $stock = $this->getDoctrine()->getRepository(Stock::class)->findBy(['userId' => $user, 'deleted' => NULL]);

return $this->json($stock);
    }

/**
     * Delete an Entity's related entities if entity is one of item, category, supply, orders, stock
     *
     * @param string $query Entity name
     * @param int $id
     *
     * @Route("/admin/delete/{query}/{id}", name="delete")
     */
    public function delete($query, $id)
    {
        $user = $this->getUser()->getId();
        $em = $this->getDoctrine()->getManager();
        $item = $em->getRepository("App\Entity\\$query")->findOneBy(['id' => $id, 'userId' => $user]);

if ($item && in_array($query, ['Category', 'Supply', 'Orders', 'Item', 'Stock'])) {
            switch ($query) {
                case 'Supply':
                    $this->getDoctrine()->getRepository(SupplyItem::class)->deleteSupplyItems($id, $user);
                    break;
                case 'Item':
                    $this->getDoctrine()->getRepository(ItemPart::class)->deleteByItem($id, $user);
                    break;
                case 'Stock':
                    $this->getDoctrine()->getRepository(ItemPart::class)->deleteByStock($id, $user);
                    break;
                case 'Orders':
                    $this->getDoctrine()->getRepository(OrderItem::class)->deleteByOrder($id, $user);
                    break;
                case 'Category':
                    $this->getDoctrine()->getRepository(Item::class)->deleteByCategory($id, $user);
                    break;
                default:

break;
            }
            // foreach ($items as $individual) {
            //     $em->remove($individual);
            // }
        }
        // $em->remove($item);
        // $em->flush();
        $route = strtolower($query);
        return $route;
    }

/**
     * @Route("/admin/items/delete/{id}", name="removeitem")
     *
     * @param int $id Item ID
     **/
    public function removeItem($id)
    {
        $user = $this->getUser()->getId();
        $em = $this->getDoctrine()->getManager();
        $item = $em->getRepository(Item::class)->findOneBy(['id' => $id, 'userId' => $user]);
        $this->delete('Item', $id);

$item->setDeleted(true);
        $em->persist($item);
        $em->flush();

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

/**
     * @Route("/admin/inventory/delete/{id}", name="removeinventoryitem")
     *
     * @param int $id Inventory ID
     **/
    public function removeInventoryItem($id)
    {
        $user = $this->getUser()->getId();
        $em = $this->getDoctrine()->getManager();
        $stock = $em->getRepository(Stock::class)->findOneBy(['id' => $id, 'userId' => $user]);
        $this->delete('Stock', $id);

$stock->setDeleted(true);
        $em->persist($stock);
        $em->flush();

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

/**
     * Delete Item part
     *
     * @param int $id
     * @Route("/admin/stockitem/remove/{id}", name="removeStockItem")
     */
    public function stockItemRemoveAction($id)
    {
        $user = $this->getUser()->getId();
        $itempart = $this->getDoctrine()->getRepository(ItemPart::class)->findOneBy(['id' => $id, 'userId' => $user]);
        $em = $this->getDoctrine()->getManager();
        $em->remove($itempart);
        $em->flush();
        return $this->redirectToRoute('item', array('id' => $itempart->getItemId()));
    }

// public function deleteCategory($id)
    // {
    //     $user = $this->getUser()->getId();
    //     $em = $this->getDoctrine()->getManager();
    //     $category = $em->getRepository(Groups::class)->findOneBy(['id' => $id, 'userId' => $user]);
    //     $items = $em->getRepository(Item::class)->findBy(['cId' => $id, 'userId' => $user]);
    //     foreach ($items as $item) {
    //         $this->delete('Item', $item->getId());
    //         // $em->remove($item);
    //     }
    //     $em->getRepository(Item::class)->deleteByCategory($category, $user);
    //     $em->remove($category);
    //     $em->flush();

//     return $this->redirectToRoute('group');

// }

public function check($entity, $name, $value)
    {
        $user = $this->getUser()->getId();
        $item = $this->getDoctrine()->getRepository('App\Entity\\' . $entity)->findOneBy(array($name => $value, 'userId' => $user));
        // var_dump($item);
        if ($item) {
            if ($item->getDeleted()) {
                return $item->getId();
            }
            return $this->json("$name is already in use");
        }else {
            return false;
        }
    }
}