Elep

<?php

namespace App\Http\Controllers;

use App\Http\Services\ImageManager;
use App\Http\Services\PostImageUploader;
use App\Jobs\ProcessImage;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use App\Mail\RegisterTester;
use App\Mail\RegisterUser;
use App\User;
use AWS\CRT\HTTP\Response;
use Illuminate\Support\Facades\Mail;

class AdminController extends Controller
{
	private $db;

const EXPLORE_TAGS = [
		'breakfast' => 'Breakfast',
		'grill' => 'Grill',
		'pizza' => 'Pizza',
		'chinese' => 'Chinese',
		'indian' => 'Indian',
		'italian' => 'Italian',
		'asian' => 'Asian',
		'fast-food' => 'Fast Food',
		'appetizers' => 'Appetizers',
		'desserts' => 'Desserts',
		'salads' => 'Salads',
		'sandwiches' => 'Sandwiches',
		'burgers' => 'Burgers',
		'seafood' => 'Seafood',
		'soups' => 'Soups',
		'rice' => 'Rice',
		'pasta' => 'Pasta',
		'steak' => 'Steak',
		'vegetarian' => 'Vegetarian',
		'swallow' => 'Swallow',
		'nigerian' => 'Nigerian',
		'continental' => 'Continental',
		'mediterranean' => 'Mediterranean'
	];

function __construct()
	{
		$this->db = DB::getMongoDB();
	}

/**
	 * Get list of admin users
	 *
	 **/
	public function users(Request $request)
	{
		$type = $request->query('role');
		$users = $type ? User::whereNotNull('started')->whereNull('status')->get() : User::all();

return view('admin.users', ['users' => $users]);
	}

/**
	 * Get list of admin users
	 *
	 **/
	public function addUser(Request $request)
	{
		return view('admin.add_user');
	}

public function changeRole(Request $request)
	{
		$data = json_decode($request->getContent(), true);

$result = $this->db->users->updateOne(['email' => $data['user']], ['$set' => ['role' => $data['option']]]);

if($result->getModifiedCount()) return response()->json(['status' => 'OK', 'role' => $data['option']]);
		else return response()->json(['status' => 'error']); 
	}

public function places(Request $request)
	{
		// $places = $this->db->places->find();
		$pipeline = [];

$name = $request->query->get('place', null);

if($name) $pipeline[] = ['$match' => ['name' => ['$regex' => "$name", '$options' => "i"]]];

$pipeline[] = ['$match' => ['food' => []]];

$pipeline[] = [
			'$project' => [
				'name' => 1,
				'slug' => 1,
				'address' => 1,
				'phone' => 1,
				'opening' => 1,
				'closing' => 1,
				'type' => 1,
				'location' => 1,
				'delivery' => 1,
				'created' => 1,
				'tags' => 1,
				'image' => 1,
				'image_count' => [ '$size' => '$image' ],
				'place_name' => [ '$toLower' => '$name' ]
			]
		];

$page = $request->query->get('page', 1);
		$sort = $request->query->get('sort', '');
		$order = $request->query->get('order', '');
		$perPage = 30;

list($places, $next, $prev) = $this->paginate($request, $pipeline, 'admin_places', 'places');

return view('admin.places_no_food', ['places' => $places, 'next' => $next, 'prev' => $prev, 'page' => $page, 'link' => 'admin_places', 'sort' => $sort, 'order' => $order, 'title' => 'Places without food']);
	}

private function paginate($request, $pipeline, $route, $collection) 
	{
		$page = $request->query->get('page', 1);
		$perPage = 30;

$skip = (intval($page)-1)*$perPage;
		$sort = $request->query->get('sort', '');
		$order = $request->query->get('order', '');
		if ($sort) {
			$pipeline[] = [
				'$sort' => [
					$sort => intval($order) ?? 1
				]
			];
		}

$pipeline[] = [
            '$skip' => $skip
        ];
		
		$pipeline[] = [
			'$limit' => $perPage
		];

$next = route($route, ['page' => $page+1, 'sort' => $sort, 'order' => $order]);
		$prev = $page > 1 ? route($route, ['page' => $page-1, 'sort' => $sort, 'order' => $order]) : false;

$items = $this->db->{$collection}->aggregate($pipeline)->toArray();

$next = count($items) === $perPage ? $next : false;
		$prev = $page > 1 ? $prev : false;

return [$items, $next, $prev];
	}

public function placesWithFood(Request $request)
	{
		$pipeline = [];

$name = $request->query->get('place', null);

if($name) $pipeline[] = ['$match' => ['name' => ['$regex' => "$name", '$options' => "i"]]];
		
		$pipeline[] = ['$lookup' => 
			[
				'from' => 'fooding',
				'let' => ['id' => '$slug'],
				'pipeline' => [
					[
						'$match' => [
		                    '$expr' => [
		                        '$eq' => ['$place_slug', '$$id']
		                    ]
		                ]
	            	]
				],
				'as' => 'food'
			]
		];

$pipeline[] = ['$match' => ['food' => ['$ne' => []]]];
		
		$pipeline[] = [
			'$project' => [
				'name' => 1,
				'slug' => 1,
				'address' => 1,
				'phones' => 1,
				'opening' => 1,
				'closing' => 1,
				'type' => 1,
				'location' => 1,
				'delivery' => 1,
				'created' => 1,
				'tags' => 1,
				'image' => 1,
				'food' => 1,
				'food_count' => [ '$size' => '$food' ],
				'image_count' => [ '$size' => '$image' ],
				'place_name' => [ '$toLower' => '$name' ]
			]
		];

$next = false;

$page = $request->query->get('page', 1);
		$sort = $request->query->get('sort', '');
		$order = $request->query->get('order', '');
		$perPage = 30;

$route = 'admin_places_food';

list($places, $next, $prev) = $this->paginate($request, $pipeline, $route, 'places');

return view('admin.user_places', [
			'places' => $places, 
			'next' => $next, 
			'prev' => $prev, 
			'page' => $page, 
			'link' => $route, 
			'sort' => $sort, 
			'order' => $order, 
			'title' => 'Places with food',
			'query' => $name
		]);
	}

public function placeFood($place) 
	{
		$food = $this->db->fooding->aggregate([['$match' => ['place_slug' => $place]], [
			'$project' => [
				'_id' => ['$toString' => '$_id'],
				'name' => 1,
				'description' => 1,
				'category' => 1,
				'price' => 1
			]]
		])->toArray();

return view('admin.edit_food', ['place' => $place, 'food' => $food]);
	}

public function updateFood($place)
	{
		unset($_POST['_token']);
		$food = $this->handleArrayInput($_POST);
		$update_count = 0;
		for ($i=0; $i<count($food); $i++) {
			$update = $this->db->fooding->updateOne(
				[
					'_id' => new \MongoDB\BSON\ObjectId($food[$i]['_id'])
				],
				[
					'$set' => ['price' => $food[$i]['price']]
				],
				[
					'upsert' => true
				]
			);
			$update_count += $update->getModifiedCount();
		}

if ($update_count > 0) {
			$this->db->places->updateOne(['slug' => $place], ['$set' => ['last_food_update' => (new \DateTime())->format('d-m-Y H:i:s')]]);
		}

return redirect()->route('admin_edit_place_food', ['place' => $place]);
	}

public function addPlacePicture(Request $request, $slug)
    {
		$referer = request()->headers->get('referer');
        $images = PostImageUploader::upload($request, $slug);
        $update = $this->db->places->updateOne(
            ['slug' => $slug],
            ['$addToSet' => ['image' => ['$each' => $images]]]
        );

return redirect($referer);
    }

public function assessment()
	{
		$places = $this->db->placing->aggregate([
			['$match' => ['$or' => [['created_by' => 'obajemuabisoladeborah@gmail.com'], ['modified_by' => 'obajemuabisoladeborah@gmail.com']]]]
		])->toArray();

return view('admin.assessment', ['places' => $places]);
	}

public function assessmentEdit($place_slug)
	{
		$place = $this->db->placing->aggregate([
			['$match' => ['slug' => $place_slug]]
		])->toArray();
		if(count($place)) {
			$p = $this->db->places->insertOne($place[0]);
			if($p->getInsertedId()) {
				$foods = $this->db->foodings->aggregate([
					['$match' => ['place_slug' => $place_slug]]
				])->toArray();
				if(count($foods)) {
					$f = $this->db->fooding->insertMany($foods);
					$this->db->foodings->deleteMany(['place_slug' => $place_slug]);
				}
				$this->db->placing->deleteOne(['slug' => $place_slug]);

return redirect()->route('admin_edit_place', ['slug' => $place_slug]);
			}
		}

return redirect()->route('assessment_places');
	}

public function placesNewWithFood(Request $request)
	{
		$pipeline = [];

$name = $request->query->get('place', null);
		$sort = $request->query->get('sort', null);
		$order = $request->query->get('order', null);

if($name) $pipeline[] = ['$match' => ['name' => ['$regex' => "$name", '$options' => "i"]]];
		
		$pipeline[] = ['$lookup' => 
			[
				'from' => 'foodings',
				'let' => ['id' => '$slug'],
				'pipeline' => [
					[
						'$match' => [
		                    '$expr' => [
		                        '$eq' => ['$place_slug', '$$id']
		                    ]
		                ]
	            	]
				],
				'as' => 'food'
			]
		];

$pipeline[] = ['$match' => ['food' => ['$ne' => []]]];
		$page = $request->query->get('page', 1);
		$perPage = 30;

$skip = (intval($page)-1)*$perPage;
        $pipeline[] = [
            '$skip' => $skip
        ];

if ($sort) {
			$pipeline[] = [
				'$sort' => [
					$sort => $order ?? -1
				]
			];
		}
		
		$pipeline[] = [
			'$limit' => $perPage
		];

$next = false;

$places = $this->db->places->aggregate($pipeline)->toArray();

$next = count($places) === $perPage ? true : false;
		$prev = $page > 1 ? true : false;

return view('admin.new_places', ['places' => $places, 'next' => $next, 'prev' => $prev, 'page' => $page, 'link' => 'admin_new_places_food']);
	}

private function caps($name)
	{
		$upper = function($k, $str) {
			$not_in = ['in', 'with', 'of', 'and', 'on', 'by', 'the'];
			return in_array(strtolower($str), $not_in) && ($k != 0) ? strtolower($str) : ucfirst($str);
		};
		$pieces = explode(" ", $name);
		return implode(" ", array_map($upper, array_keys($pieces), $pieces));
	}

public function registered(Request $request)
	{
		$page = $request->query('page', 1);
		$perPage = 20;
		$skip = (intval($page)-1)*$perPage;

$search = $request->query('claimed');

$query = $search ? ['claimed' => 'true'] : [];

$places = $this->db->register->find($query, ['skip' => $skip, 'limit' => $perPage])->toArray();

$next = count($places) === $perPage ? true : false;
		$prev = $page > 1 ? true : false;

return view('admin.registered_places', ['places' => $places, 'next' => $next, 'prev' => $prev, 'page' => $page, 'link' => 'admin_registered_places', 'search' => $search]);
	}

public function addFood($place_slug)
	{
		$place = $this->db->places->findOne(['slug' => $place_slug]);
		return view('admin.add_food', ['place' => $place]);
	}

public function saveFood(Request $request)
	{
		$place = $this->db->places->findOne(['slug' => $_POST['place']]);
		
		unset($_POST['_token'], $_POST['place']);
		$f = $this->handleArrayInput($_POST);
		
		$images = PostImageUploader::upload($request, $place['slug']);
        $db = DB::getMongoDB();
		$user = $request->user();

foreach($f as $i => $food) {
			$food['place_name'] = $place['name'];
			$food['place_slug'] = $place['slug'];

$food['created'] = (new \DateTime('now'))->format('d-m-Y H:i:s');
			$food['created_by'] = (string) $user->email;

if(isset($images[$i])) {
				$food['img'] = $images[$i];
			}

$db->fooding->insertOne($food);
        }

return redirect()->route('admin_add_place_food', ['place_slug' => $place['slug']]);
	}

/**
     * 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 addPlace($slug)
	{
		$place = $this->db->placing->findOne(['slug' => $slug]);
		$place['name'] = $this->caps($place['name']);
		$place['nickname'] = preg_replace("/[')(]/", "", $place['name']);
		$place['category'] = $place['category'] ?? [];
		$place['likes'] = $place['likes'] ?? [];
		$place['enabled'] = $place['enabled'] ?? true;
		$insert = $this->db->places->insertOne($place);

if($insert->getInsertedCount()) {
			$foods = $this->db->foodings->find(['place_slug' => $slug])->toArray();
			if(count($foods)) {
				$this->db->fooding->insertMany($foods);
				$this->db->foodings->updateMany(['place_slug' => $slug], ['$set' => ['added' => true]]);
			}
			$this->db->placing->updateOne(['slug' => $slug], ['$set' => ['added' => true]]);
		}		
		return redirect()->route('admin_new_places_food');
	}

public function addAllFood(Request $request, $slug)
	{
		$newPlace = $this->db->placing->findOne(['slug' => $slug]);

$data = json_decode($request->getContent(), true);
		$foods = $this->db->foodings->find(['place_slug' => $slug], ['projection' => ['key' => (string) '$_id', '_id' => 0, 'name' => 1, 'price' => 1]])->toArray();
		for ($i=0; $i < count($foods); $i++) { 
			$foods[$i]['place_slug'] = $data['slug'];
		}

$insertIds = $this->db->fooding->insertMany($foods);

if(count($insertIds->getInsertedIds())){

$this->db->places->updateOne(['slug' => $data['slug']], ['$push' => ['category' => $newPlace['category'] ?? []]]);
			$this->db->foodings->deleteMany(['place_slug' => $slug]);
			return response()->json(['status' => 'success', 'food' => $foods]);
		}

return response()->json(['status' => 'error'], 500);
	}

public function replaceFood(Request $request, $slug)
	{
		$newPlace = $this->db->placing->findOne(['slug' => $slug]);

$place = json_decode($request->getContent(), true);
		$newfoods = $this->db->foodings->find(['place_slug' => $slug], ['projection' => ['key' => (string) '$_id', '_id' => 0, 'name' => 1, 'price' => 1]])->toArray();
		for ($i=0; $i < count($newfoods); $i++) { 
			$newfoods[$i]['place_slug'] = $place['slug'];
		}

$this->db->fooding->deleteMany(['place_slug' => $place['slug']]);
		$insertIds = $this->db->fooding->insertMany($newfoods);

if(count($insertIds->getInsertedIds())){

$this->db->places->updateOne(['slug' => $place['slug']], ['$set' => ['category' => $newPlace['category'] ?? []]]);
			$this->db->foodings->deleteMany(['place_slug' => $slug]);
			return response()->json(['status' => 'success', 'food' => $newfoods]);
		}

return response()->json(['status' => 'error'], 500);

}

public function addFoodToOriginal($slug, $foodid)
	{
		$place = $this->db->places->findOne(['slug' => $slug]);
		if($place){
			$food = $this->db->foodings->findOne(['_id' => new \MongoDB\BSON\ObjectId($foodid)]);
			if($food) {
				$food['place_slug'] = $slug;
				$food['place_name'] = $place['name'];
				$insert = $this->db->fooding->insertOne($food);
				if($insert->getInsertedCount()){
					$this->db->foodings->deleteOne(['_id' => new \MongoDB\BSON\ObjectId($foodid)]);
					return response()->json([
						'status' => 'success', 
						'food' => [
							'id' => (string) $food['_id'], 
							'name' => $food['name'], 
							'price' => $food['price']
						]
					]);
				}
			}
		}

return response()->json(['status' => 'error']);
	}

public function Place(Request $request, $slug)
    {
		$data = json_decode($request->getContent(), true);

$result = $this->db->places->updateOne(['slug' => $slug], ['$push' => ['image' => $data['link']]]);
		// dd($place);
        if($result->getModifiedCount()){
			return response()->json(['status' => 'success']);
		}elseif($result->getMatchedCount() == 0) {
			return response()->json(['status' => 'error', 'message' => 'Place not found'], 404);
		}
    }

public function placesWithFoodPopular(Request $request)
	{
		$pipeline = [];

$name = $request->query->get('place', null);

$pipeline[] = ['$match' => ['food' => ['$ne' => []]]];
		$page = $request->query->get('page', 1);
		$perPage = 30;

$pipeline[] = [
			'$sort' => ['popular' => -1, 'foods.food_count' => -1]
		];

$skip = (intval($page)-1)*$perPage;
        $pipeline[] = [
            '$skip' => $skip
        ];
		
		$pipeline[] = [
			'$limit' => $perPage
		];

$next = false;

$places = $this->db->places->aggregate($pipeline)->toArray();

$next = count($places) === $perPage ? true : false;
		$prev = $page > 1 ? true : false;

// var_dump($places);die;

return view('admin.popular', [
			'places' => $places, 
			'next' => $next, 
			'prev' => $prev, 
			'page' => $page, 
			'link' => 'highest_food_places',
			'query' => $name
		]);
	}

public function placesWithFoodNotIn(Request $request)
	{
		$pipeline = ['$lookup' => 
			[
				'from' => 'fooding',
				'let' => ['id' => '$slug'],
				'pipeline' => [
					[
						'$match' => [
		                    '$expr' => [
		                        '$eq' => ['$place_slug', '$$id']
		                    ]
		                ]
	            	]
				],
				'as' => 'food'
			]
		];

$page = $request->query->get('page', null);
		$perPage = 30;
		if($page){
            $skip = (intval($page)-1)*$perPage;
            $pipeline[] = [
                '$skip' => $skip
            ];

$pipeline[] = [
                '$limit' => $perPage
            ];
        }
		$places = $this->db->places->aggregate([$pipeline, ['$match' => ['food' => ['$ne' => []], 'lockdown' => ['$exists' => false], 'takeaway' => ['$exists' => false], 'delivery' => ['$size' => 0]]]])->toArray();

return view('admin.user_places', ['places' => $places]);
	}

public function enablePlace(Request $request, $slug)
	{
		$data = json_decode($request->getContent(), true);
		$update = $this->db->places->updateOne(['slug' => $slug], ['$set' => ['enabled' => $data['checked'] === "yes" ? true : false]]);

if($update->isAcknowledged()){
			return response()->json(['status' => 'success']);
		}else {
			return response()->json(['status' => 'failed']);
		}
	}

public function lrf(Request $request, $slug)
	{
		$data = json_decode($request->getContent(), true);
		$update = $this->db->places->updateOne(['slug' => $slug], ['$set' => ['lrf' => $data['checked'] === "yes" ? true : false]]);

if($update->isAcknowledged()){
			return response()->json(['status' => 'success']);
		}else {
			return response()->json(['status' => 'failed']);
		}
	}

public function setPopularity(Request $request, $slug)
	{
		$data = json_decode($request->getContent(), true);
		$update = $this->db->places->updateOne(['slug' => $slug], ['$set' => ['popularity' => intval($data['popularity'])]]);

if($update->isAcknowledged()){
			return response()->json(['status' => 'success']);
		}else {
			return response()->json(['status' => 'failed']);
		}
	}

public function addCategory($slug)
	{
		$place = $this->db->places->findOne(['slug' => $slug]);
		return view('admin.place', ['place' => $place]);
	}

public function category(Request $request, $slug)
	{
		$data = json_decode($request->getContent(), true);
		// dd($data);
		if(is_array($data['category'])){
			$update = ['$addToSet' => ['category' => ['$each' => $data['category']]]];
		}else {
			$update = ['$addToSet' => ['category' => $data['category']]];
		}

$update = $this->db->places->updateOne(['slug' => $slug], $update);

if($update->isAcknowledged()){
			$place_cat = $this->db->places->findOne(['slug' => $slug], ['projection' => ['_id' => 0, 'category' => 1]]);
			// dd($place_cat);
			return response()->json($place_cat);
		}else {
			return response()->json(['status' => 'failed']);
		}
	}

public function placeFoodCategory($slug)
	{
		$place = $this->db->places->aggregate([
			['$match' => ['slug' => $slug]],
			['$lookup' => [
				'from' => 'fooding',
				'let' => ['id' => '$slug'],
				'pipeline' => [
					['$match' => ['$expr' => ['$eq' => ['$place_slug', '$$id']]]],
					['$project' => ['_id' => (string) '$_id', 'name' => 1, 'category' => 1, 'description' => 1, 'price' => 1]]
				],
				'as' => 'food'
			]]
		])->toArray();

return view('admin.place_food', ['place' => $place[0]]);
	}

public function savePlaceFoodCategory($slug)
	{
		unset($_POST['_token']);
		foreach ($_POST as $_id => $category) {
			$this->db->fooding->updateOne(['_id' => new \MongoDB\BSON\ObjectId($_id)], ['$set' => ['category' => $category]]);
		}

return redirect()->route('place_food_category', ['slug' => $slug]);
	}

public function updateFoodCategory(Request $request)
	{
		$data = json_decode($request->getContent(), true);
		$this->db->fooding->updateOne(['_id' => new \MongoDB\BSON\ObjectId($data['id'])], ['$set' => ['category' => $data['category']]]);

return response()->json(['status' => 'success']);
	}

public function showExplorePictures(Request $request)
	{
		$search = $request->query('search', '');
		$picsPipeline = [
			['$match' => 
				[
					'$or' => [
						['place_name' => ['$regex' => $search, '$options' => 'i']],
						['food' => ['$regex' => $search, '$options' => 'i']],
						['tags' => ['$regex' => $search, '$options' => 'i']]
					]
				]
			
			]
		];
		list($items, $next, $prev) = $this->paginate($request, $picsPipeline, 'admin_explore_pictures', 'food_explore');

// $this->db->food_explore->a
		return view('admin.explore_pictures', ['title' => 'Explore Food Pictures', 'items' => $items, 'prev' => $prev, 'next' => $next, 'link' => 'admin_explore_pictures', 'search' => $search]);
	}

public function explorePlaceImages(Request $request)
	{
		$pipeline = [];

$name = $request->query->get('place', null);

if($name) $pipeline[] = ['$match' => ['name' => ['$regex' => "$name", '$options' => "i"]]];

$page = $request->query->get('page', 1);
		$perPage = 30;

// $pipeline[] = [
		// 	'$sort' => ['popular' => -1]
		// ];

$skip = (intval($page)-1)*$perPage;
        $pipeline[] = [
            '$skip' => $skip
        ];
		
		$pipeline[] = [
			'$limit' => $perPage
		];

$next = false;

$places = $this->db->places->aggregate($pipeline)->toArray();

$next = count($places) === $perPage ? true : false;
		$prev = $page > 1 ? true : false;

$images = $this->db->food_explore->find([], ['_id' => 0, 'image' => 1])->toArray();
		$imgs = array_column($images, 'image');
		
		return view('admin.explore_places', [
			'places' => $places, 
			'next' => $next, 
			'prev' => $prev, 
			'page' => $page, 
			'link' => 'explore_places',
			'query' => $name,
			'images' => $imgs
		]);
	}

public function make_explore(Request $request, $slug)
	{
		$data = json_decode($request->getContent(), true);
		$place = $this->db->places->findOne(['slug' => $slug]);
		if($data['checked'] == 'yes') {
			$res = $this->db->food_explore->insertOne([
				'place_slug' => $slug,
				'place_name' => $data['placename'],
				'image' => $data['image'],
				'category' => $place->category ?? [],
				'tags' => $place->tags ?? [],
				'type' => $place->type ?? '',
				'created_at' => new \MongoDB\BSON\UTCDateTime()
			]);
		}else {
			$res = $this->db->food_explore->deleteOne(['image' => $data['image']]);
		}

return response()->json(['status' => 'success']);
	}

public function addExploreTags(Request $request)
	{
		$search = $request->query('search', '');
		$picsPipeline = [
			['$match' => 
				[
					'$or' => [
						['place_name' => ['$regex' => $search, '$options' => 'i']],
						['food' => ['$regex' => $search, '$options' => 'i']],
						['tags' => ['$regex' => $search, '$options' => 'i']]
					]
				]
			
			]
		];
		list($items, $next, $prev) = $this->paginate($request, $picsPipeline, 'add_explore_tags', 'food_explore');

// $this->db->food_explore->a
		return view('admin.explore_tags', ['title' => 'Explore Tags', 'items' => $items, 'prev' => $prev, 'next' => $next, 'link' => 'add_explore_tags', 'search' => $search, 'tags' => self::EXPLORE_TAGS, 'explore_images' => $items]);
	}

public function saveExploreTags(Request $request, $id)
	{
		$data = json_decode($request->getContent(), true);
		$tags = array_values(array_filter($data));

if (count($tags) == 1 && $tags[0].startsWith('none')) {
			$update = $this->db->food_explore->updateOne(['_id' => new \MongoDB\BSON\ObjectId($id)], ['$unset' => ['tags' => []]]);
		}else {
			$update = $this->db->food_explore->updateOne(['_id' => new \MongoDB\BSON\ObjectId($id)], ['$set' => ['tags' => $tags]]);
		}

if($update->isAcknowledged()){
			return response()->json(['status' => 'success']);
		}else {
			return response()->json(['status' => 'failed']);
		}
	}

public function deleteExplore(Request $request, $id)
	{
		$d = $this->db->food_explore->deleteOne(['_id' => new \MongoDB\BSON\ObjectId($id)]);

return response()->json(['status' => $d->getDeletedCount() ? 'success' : 'failed']);
	}

public function searches(Request $request)
	{
		$page = $request->query->get('page', 1);
		$perPage = 30;

$skip = (intval($page)-1)*$perPage;

$search = $this->db->logs->aggregate([
			['$skip' => $skip],
			['$limit' => $perPage]
		])->toArray();

$next = count($search) === $perPage ? true : false;
		$prev = $page > 1 ? true : false;

return view('admin.search', ['search' => $search, 'next' => $next, 'prev' => $prev, 'page' => $page, 'link' => 'admin_logs']);
	}

public function address(string $address)
	{
	    $db = DB::getMongoDB();

$pipeline = [];
	    $pipeline[] = [
	        '$match' => ['address' => ['$regex' => "$address", '$options' => 'i'], 'phones' => ['$ne' => []]]
	    ];
	    $pipeline[] = ['$lookup' => [
	        'from' => 'fooding',
	        'localField' => 'slug',
	        'foreignField' => 'place_slug',
	        'as' => 'food'
	    ]];
	    // $pipeline[] = ['$match' => ['$or' => [['food' => null], ['food' => ['$size' => 0]]]]];
	    $pipeline[] = ['$match' => ['food' => ['$ne' => []]]];
	    $pipeline[] = ['$project' => ['_id' => 0, 'name' => 1, 'address' => 1, 'phones' => 1, 'opening' => 1, 'closing' => 1]];
	    // $places = $db->places->find(['address' => ['$regex' => "$address", '$options' => 'i']]);
	    $places = $db->places->aggregate($pipeline)->toArray();

return response()->json($places);
	}

public function popular($slug, $val)
	{
		$db = DB::getMongoDB();

// var_dump($pop);die;

$db->places->updateOne(['slug' => $slug], ['$set' => ['popular' => $val === "yes" ? true : false]]);

return response()->json(['status' => 'success']);
	}

public function deleteLog(Request $request, $id)
	{
		$this->db->logs->deleteOne(['_id' => new \MongoDB\BSON\ObjectId($id)]);
		return response()->json(['status' => 'success']);
	}

/**
	 * Get list of user places
	 *
	 **/
	public function userplaces($id, Request $request)
	{
		$user = $this->db->users->findOne(['_id' => new \MongoDB\BSON\ObjectId($id)]);

$pipeline = [];

$pipeline[] = ['$lookup' => 
			[
				'from' => 'foodings',
				'let' => ['id' => '$slug'],
				'pipeline' => [
					[
						'$match' => [
		                    '$expr' => [
		                        '$eq' => ['$place_slug', '$$id']
		                    ],
		                    // '$or' => [['created_by' => $user['email']], ['modified_by' => $user['email']]]
		                ]
	            	],
	            	[
	            		'$sort' => ['name' => 1]
	            	]
				],
				'as' => 'food'
			]
		];

$name = $request->query->get('place', null);

if($name) $pipeline[] = ['$match' => ['name' => ['$regex' => "$name", '$options' => "i"]]];

// $pipeline[] = ['$match' => ['food' => ['$ne' => []]]];
		$pipeline[] = ['$match' => ['$or' => [['created_by' => $user['email']], ['modified_by' => $user['email']]]]];
		
		$result = $this->paginateResults($request, 'places', $pipeline);

// return response()->json(['places' => $places->toArray(), 'user' => $user]);
		return view('admin.user_places', ['user' => $user, 'places' => $result['items'], 'prev' => $result['prev'], 'next' => $result['next'], 'page' => $result['page'], 'link' => 'user_places']);
	}

private function paginateResults($request, $collection, $pipeline)
	{
		$result = array();
		$page = $request->query->get('page', 1);
		$perPage = 100;

$skip = (intval($page)-1)*$perPage;
        $pipeline[] = [
            '$skip' => $skip
        ];
		
		$pipeline[] = [
			'$limit' => $perPage
		];

$result['items'] = $this->db->{$collection}->aggregate($pipeline)->toArray();

$count = count($result['items']);
		$result['next'] = $count === $perPage ? true : false;
		
		$result['prev'] = $page > 1 ? true : false;
		$result['page'] = $page;

return $result;
	}

public function userAnswers(Request $request, $email)
	{
		$user = $this->db->users->findOne(['email' => $email]);
		$answers = $this->db->answers->find(['user' => $email], ['sort' => ['question' => 1]])->toArray();

return view('admin.answers', ['answer' => $answers, 'user' => $user]);
	}

/**
	 * Get list of admin users
	 *
	 **/
	public function deleteUser($id, Request $request)
	{
		$user = User::find($id);
		$user->delete();

return redirect()->route('admin_users');
	}

public function deleteFood($id)
	{
		$result = $this->db->fooding->deleteOne(['_id' => new \MongoDB\BSON\ObjectId($id)]);

return response()->json($result);
	}

public function deleteNewFood($id)
	{
		$result = $this->db->foodings->deleteOne(['_id' => new \MongoDB\BSON\ObjectId($id)]);

return response()->json($result);
	}

public function fixImages($slug)
	{
		$place = $this->db->placing->findOne(['slug' => $slug]);
		foreach ($place['image'] as $i => $url) {
            try {
                $im = new ImageManager();
				$relpath = parse_url($url)['path'];
				$filePath = storage_path('app/public') . $relpath;
				// var_dump($filePath);die;
                $source = $im->fromFile($filePath);
                $path = env('S3_BUCKET') . $relpath;

$credentials = array(
					"service" => "s3",
					"aws_access_key_id" => env('S3_KEY'),
					"aws_secret_access_key" => env('S3_SECRET'),
					"region" => env('S3_REGION')
				);

$credentials['path'] = $path;

$resized = $source->resize(array(
                    "method" => "cover",
                    "width" => 600,
                    "height" => 600
                ));
                $resized->store($credentials);

if (file_exists($filePath)) {
                    try {
                        unlink($filePath);
                    } catch (\Exception $e) {
                        
                    }
                }

} catch (\Exception $e) {
                // $notdone[] = intval($i);
				// return response()->json(['message' => $e->getMessage()]);
            }
        }

return response()->json(['message' => 'success']);
	}

/**
	 * Find and return a list of foods with name similar to query
	 * @param Request @request
	 */
	public function findFoodByName(Request $request)
	{
		$query = $request->query('food');
		$foods = [];

if ($query) {
			$db = DB::getMongoDB();
			$foods = $db->fooding->find(
				[
					'name' => [
						'$regex' => "$query", 
						'$options' => "i"
					]
				], 
				[
					'projection' => [
						'id' => (string) '$_id', 
						'name' => 1,
						'place_name' => 1,
						'place_slug' => 1
					]
				]
			)->toArray();
		}

return view('admin.find_food', ['foods' => $foods, 'query' => $query]);
	}

public function addTagsToFood()
	{
		$db = DB::getMongoDB();
		$mongo_ids = array_map(function($id) {
			return new \MongoDB\BSON\ObjectId($id);
		}, $_POST['food']);

$result = $db->fooding->updateMany(['_id' => ['$in' => $mongo_ids]], ['$addToSet' => ['tags' => ['$each' => array_filter($_POST['tag'])]]]);

return redirect()->route('admin_find_food_by_name');
	}

private function getFranchises()
	{
		return $this->db->places->aggregate([
			[
				'$group' => [
					'_id' => '$franchise',
					'count' => ['$sum' => 1]
				]
			]
		])->toArray();
	}

public function franchise(Request $request)
	{
		$query = $request->query('query');
		$places = [];
		$franchises = $this->getFranchises();
		// var_dump($franchises);die;
		if ($query) {
			$db = DB::getMongoDB();
			$places = $db->places->find(
				[
					'name' => [
						'$regex' => "^$query", 
						'$options' => "i"
					]
				], 
				[
					'projection' => [
						'id' => (string) '$_id', 
						'name' => 1,
						'address' => 1,
						'slug' => 1,
						'food_count' => 1
					]
				]
			)->toArray();
		}
		return view('admin.franchise', ['places' => $places, 'query' => $query, 'franchises' => $franchises]);
	}

public function setFranchise(Request $request)
	{
		$data = $request->all();
		$franchise_name	= $data['franchise_name'];
		unset($data['_token'], $data['franchise_name']);
		$franchises = array_column($this->handleArrayInput($data), 'franchise');
		
		$this->db->places->updateMany(['slug' => ['$in' => $franchises]], ['$set' => ['franchise' => $franchise_name, 'franchise_count' => count($franchises)]]);

return redirect()->route('franchise');
	}

public function beginPopulateFranchise($franchise)
	{
		$pipeline = [];
		// $places = $this->db->places->find([
		// 	'franchise' => $franchise
		// ])->toArray();
		$pipeline[] = [
			'$match' => [
				'franchise' => $franchise
			]
		];

$pipeline[] = ['$lookup' => 
			[
				'from' => 'fooding',
				'let' => ['id' => '$slug'],
				'pipeline' => [
					[
						'$match' => [
		                    '$expr' => [
		                        '$eq' => ['$place_slug', '$$id']
		                    ]
		                ]
	            	]
				],
				'as' => 'food'
			]
		];
		
		// $this->db->places->updateMany(['slug' => ['$in' => $franchises]], ['$set' => ['franchise' => $franchise_name, 'franchise_count' => count($franchises)]]);
		$places = $this->db->places->aggregate($pipeline)->toArray();
		return view('admin.franchise_populate', ['places'=> $places]);
	}

public function populateFranchise(Request $request)
	{
		$data = $request->all();

if (!isset($data['props']) || empty($data['props'])) {
			return redirect()->route('franchise');
		}

$place = $this->db->places->findOne(['slug' => $data['franchise-place']]);
		$names = $slugs = [];
		foreach ($data['franchise'] as $name_slug) {
			list($slug, $name) = explode('::', $name_slug);
			$names[] = $name;
			$slugs[] = $slug;
		}
		$update = [];

if (in_array('type', $data['props'])) {
			$update['type'] = $place->type;
		}
		if (in_array('opening', $data['props'])) {
			$update['opening'] = $place->opening;
			$update['closing'] = $place->closing;
		}
		if (in_array('tags', $data['props']) && isset($place->tags)) {
			$update['tags'] = $place->tags;
		}
		if (in_array('phones', $data['props'])) {
			$update['phones'] = $place->phones;
		}

if (count($update)) {
			$updateResult = $this->db->places->updateMany(
				['slug' => ['$in' => $slugs]],
				['$set' => $update]
			);
		}

if (in_array('food', $data['props'])) {
			$foods = $this->db->fooding->find(['place_slug' => $place->slug], ['projection' => ['_id' => 0]])->toArray();
				// unset($foods['_id']);
				// var_dump($foods);die;

foreach ($slugs as $i => $slug) {
				// list($slug, $name) = explode("::", $franchise);
				$this->db->fooding->deleteMany(['place_slug' => $slug]);
				$new_food = [];
				foreach ($foods as $k => $food) {
					$new_food[$k] = $food;
					$new_food[$k]['place_slug'] = $slug;
					$new_food[$k]['place_name'] = $names[$i];
				}
				$this->db->fooding->insertMany($new_food);
			}
		}

return redirect()->route('franchise');
	}

public function saveFoodCount()
	{
		$places = $this->db->places->find()->toArray();
		foreach ($places as $place) {
			$food_count = $this->db->fooding->count(['place_slug' => $place['slug']]);
			$this->db->places->updateOne(['slug' => $place['slug']], ['$set' => ['food_count' => $food_count]]);
		}

return response()->json(['message' => 'success']);
	}

public function handleExploreImages()
    {
		$credentials = array(
            "service" => "s3",
            "aws_access_key_id" => env('S3_KEY'),
            "aws_secret_access_key" => env('S3_SECRET'),
            "region" => env('S3_REGION')
        );
        $pics = $this->db->food_explore->find()->toArray();

if($pics && count($pics)){
            
            foreach ($pics as $i => $file) {
				try {
					$uniq_id = uniqid() . "-" . $file['_id'];
					$im = new ImageManager();
					$source = $im->fromUrl($file['image']);
					$base_image = '/explore/images/' . $uniq_id . '.jpg';

$path = env('S3_BUCKET') . $base_image;
					$credentials['path'] = $path;

$resized = $source->resize(array(
						"method" => "cover",
						"width" => 500,
						"height" => 500
					));
					$resized->store($credentials);

$image_path = env('S3_BASE_URL') . $base_image;

$this->db->food_explore->updateOne(['_id' => $file['_id']], ['$set' => ['resized' => $image_path]]);
				} catch (\Exception $e) {
					$this->db->food_explore->updateOne(['_id' => $file['_id']], ['$set' => ['resized' => $file['image']]]);
				}
            }
		}

return response()->json(['message' => 'done']);
    }

public function handleExploreAddress()
    {
        $explores = $this->db->food_explore->find(['place_address' => ['$exists' => false]])->toArray();

if($explores && count($explores)){
            
            foreach ($explores as $file) {
				$pl = $this->db->places->findOne(['name' => trim($file['place_slug'])]);

if ($pl) {
					$this->db->food_explore->updateOne(['_id' => $file['_id']], ['$set' => ['place_address' => $pl['address']]]);
				}
            }
		}

return response()->json(['message' => 'done']);
    }
}