Elep

<?php

namespace App\Http\Controllers;

use App\Http\Services\ImageManager;
use App\Http\Services\PostImageUploader;
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;

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[] = ['$lookup' => 
			[
				'from' => 'fooding',
				'let' => ['id' => '$slug'],
				'pipeline' => [
					[
						'$match' => [
		                    '$expr' => [
		                        '$eq' => ['$place_slug', '$$id']
		                    ]
		                ]
	            	]
				],
				'as' => 'food'
			]
		];

$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($pipeline, $next, $prev) = $this->paginate($request, $pipeline, 'admin_places');

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

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

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) 
	{
		$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;

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

private function sortPipeline($request, $pipeline = []) {
		$sort = $request->query->get('sort', '');
		$order = $request->query->get('order', '');
		if ($sort) {
			$pipeline[] = [
				'$sort' => [
					$sort => intval($order) ?? 1
				]
			];
		}

return $pipeline;
	}

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,
				'phone' => 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;

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

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

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

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

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

return view('admin.user_places', [
			'places' => $places, 
			'next' => $next, 
			'prev' => $prev, 
			'page' => $page, 
			'link' => 'admin_places_food', 
			'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);
        $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 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 addExploreFood()
	{
		return view('food.add_picture');
	}

public function storeExploreFood(Request $request)
	{
		$data = json_decode($request->getContent(), true);
		$res = $this->db->food_explore->insertOne([
			'place_slug' => $data['place'],
			'place_name' => $data['placename'],
			'food' => $data['foodname'],
			'food_id' => $data['id'],
			'image' => $data['image'],
			'created_at' => new \MongoDB\BSON\UTCDateTime()
		]);
		if ($res->getInsertedId()) {
			return response()->json(['status' => 'success']);
		} else {
			return response()->json(['status' => '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']);
	}

public function tolockdown()
	{
		$pipeline = [
			'$lookup' =>
			[
				'from' => 'fooding',
				'let' => ['id' => '$slug'],
				'pipeline' => [
					[
						'$match' => [
							'$expr' => [
								'$eq' => ['$place_slug', '$$id']
							]
						]
					]
				],
				'as' => 'food'
			]
		];
		$places = $this->db->places->aggregate([$pipeline, ['$match' => ['food' => ['$ne' => []]]]])->toArray();

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

public function lockdown()
	{
		$pipeline = [
			'$lookup' =>
			[
				'from' => 'fooding',
				'let' => ['id' => '$slug'],
				'pipeline' => [
					[
						'$match' => [
							'$expr' => [
								'$eq' => ['$place_slug', '$$id']
							]
						]
					]
				],
				'as' => 'food'
			]
		];
		$places = $this->db->places->aggregate([$pipeline, ['$match' => ['food' => ['$ne' => []], 'lockdown' => true]]])->toArray();

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

public function deleteLockdown($slug)
	{
		$place = $this->db->places->updateOne(['slug' => $slug], ['$set' => ['lockdown' => false]]);
		$delete = $this->db->lockdown->deleteOne(['slug' => $slug]);
		$response = ['status' => 'success', 'place' => $place];

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

public function saveLockdown(Request $request, $slug)
	{
		$data = json_decode($request->getContent(), true);
		if ($data['lockdown']) {
			$this->db->places->updateOne(
				[
					'slug' => $slug
				],
				[
					'$set' => [
						'address' => $data['address'],
						'phones' => array_merge($data['phoneone'], $data['phonetwo']),
						'opening' => $data['opening'],
						'closing' => $data['closing'],
						'location' => [
							'type' => 'Point',
							'coordinates' => [floatval($data['longitude']), floatval($data['latitude'])]
						],
						'lockdown' => $data['lockdown']
					]
				]
			);

$place = $this->db->places->findOne(['slug' => $slug]);

$this->db->lockdown->insertOne($place);	
			$response = ['status' => 'success', 'place' => $place];
		}else {
			$response = ['message' => 'failed', 'place' => null];
		}

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

/**
	 * 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']]]]];
		
		
		$page = $request->query->get('page', 1);
		$perPage = 100;

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

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

$next = false;

$count = count($places);
		$next = $count === $perPage ? true : false;
		
		$prev = $page > 1 ? true : false;
		$foodCount = 0;
		foreach ($places as $place) {
			$foodCount += count($place['food']);
		}

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

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');
	}
}