def category(request, category_name_slug):
	# context dictionary to pass to the template rendering engine
	context_dict = {}
	context_dict['result_list'] = None
	context_dict['query'] = None
	if request.method == 'POST':
		query = request.POST['query'].strip()
		if query:
			# Run the Bing function to get the result list
			result_list = run_query(query)
			context_dict['result_list'] = result_list
			context_dict['query'] = query

	try:
		# if we cannot find the slug-name, get() raises DoesNotExist exception
		category = Category.objects.get(slug=category_name_slug)
		context_dict['category_name'] = category.name

		# retrieve all the pages
		pages = Page.objects.filter(category=category).order_by('-views')
		# Adds results list to the template context 
		context_dict['pages'] = pages
		# also add category object from db to the context 
		context_dict['category'] = category
		context_dict['category_name_slug'] = category_name_slug
	except Category.DoesNotExist:
		# dont do anything
		pass

	return render(request, 'rango/category.html', context_dict)

def category(request, category_name_slug):
    context_dict = {}
    context_dict['result_list'] = None
    context_dict['query'] = None
    if request.method == 'POST':
        query = request.POST['query'].strip()

        if query:
            result_list = run_query(query)

            context_dict['result_list'] = result_list
            context_dict['query'] = query


    #print category_name_slug
    try:
        category = Category.objects.get(slug=category_name_slug)
        context_dict['category_name'] = category.name
        pages = Page.objects.filter(category=category).order_by('-views')
        context_dict['pages'] = pages
        context_dict['category'] = category

    except Category.DoesNotExist:
        pass

    if not context_dict['query']:
        context_dict['query'] = category.name

    return render(request, 'rango/category.html', context_dict)

def category(request, category_name_url):
    
    context = RequestContext(request)
    category_name = decode_url(category_name_url)

    # search function    
    result_list = []
    if request.method == 'POST':
        query = request.POST['query'].strip()
        if query:
            # Run our Bing function to get the results list!
            result_list = run_query(query)
    
    context_dict = {}
    
    try:
        category = Category.objects.get(name__exact=category_name)
        pages = Page.objects.filter(category=category)
        
        
        context_dict['pages'] = pages
        context_dict['category'] = category
        context_dict['category_name'] = category.name
        context_dict['category_name_url'] = category_name_url
        context_dict['cat_list'] = get_category_list()
        context_dict['search_result_list'] = result_list
    except Category.DoesNotExist:
        pass
    
    return render_to_response('rango/category.html', context_dict, context)

def category(request, category_name_url):
    context = RequestContext(request)
    # URL doesn't handle space well, we encode them into underscores
    category_name = encoding(category_name_url)
    context_dict = {'category_name' : category_name}

    try:
        category = Category.objects.get(name = category_name)
        pages = Page.objects.filter(category = category).order_by('-views')

        context_dict['pages'] = pages
        context_dict['category_name_url'] = category_name_url
        context_dict['category'] = category
        context_dict['categories'] = get_categories()

    except Category.DoesNotExist:
        pass

    result_list = []

    if request.method == "POST":
        query = request.POST['query'].strip()

        if query:
            result_list = run_query(query)
            context_dict['result_list'] = result_list

    return render_to_response('rango/category.html', context_dict, context)

def category(request, category_name_slug):

    context_dict = {}
    context_dict["result_list"] = None
    context_dict["query"] = None
    if request.method == "POST":
        query = request.POST["query"].strip()

        if query:
            result_list = run_query(query)
            context_dict["result_list"] = result_list
            context_dict["query"] = query

    try:
        category = Category.objects.get(slug=category_name_slug)
        context_dict["category_name"] = category.name

        pages = Page.objects.filter(category=category)

        context_dict["pages"] = pages
        context_dict["category"] = category
    except Category.DoesNotExist:
        pass

    return render(request, "rango/category.html", context_dict)

def category(request, category_name_url):
	# Request our context from request
	context = RequestContext(request)

	# change underscores in category name to spaces
	category_name = decode_url(category_name_url)

	# create context dictionary to pass to template
	context_dict = {'category_name': category_name}
	context_dict['category_name_url'] = encode_url(category_name_url)
	cat_list = get_category_list()
	context_dict['cat_list'] = cat_list

	try:
		category = Category.objects.get(name=category_name)

		pages = Page.objects.filter(category=category).order_by('-views')

		# Add pages and category to the context dicitionary
		context_dict['pages'] = pages
		context_dict['category'] = category
	except Category.DoesNotExist:
		pass

	if request.method == 'POST':
		query = request.POST['query'].strip()
		if query:
			result_list = run_query(query)
			context_dict['result_list'] = result_list

	return render_to_response('rango/category.html', context_dict, context)

def category(request, category_name_slug):
    context = {}
    try:
        category = Category.objects.filter(slug=category_name_slug)[0]
        context['category_name'] = category.name
        category.views+=1
        category.save()

        pages = Page.objects.filter(category=category)
        context['pages'] = pages

        context['category'] = category
    except:
        pass

    result_list = []

    if request.method == 'POST':
        query = request.POST['query'].strip()

        if query:
            # Run our Bing function to get the results list!
            result_list = run_query(query)
            context['result_list'] = result_list


    return render(request, 'rango/category.html', context)

def category(request, category_name_url):

	context = RequestContext(request)
	category_list = get_category_list()

	category_name = category_name_url.replace('_', ' ')

	context_dict = {'category_name': category_name, 'categories': category_list}

	try:
		category = Category.objects.get(name=category_name)

		pages = Page.objects.filter(category=category).order_by('-views')

		context_dict['pages'] = pages

		context_dict['category'] = category

		context_dict['category_name_url'] = category_name_url
	
	except Category.DoesNotExist:
		pass

	if request.method == 'POST':
		query = request.POST['query'].strip()

		if query:
			#Bing function:
			result_list = run_query(query)
			context_dict['result_list'] = result_list

	return render_to_response('rango/category.html', context_dict, context)

def category(request, category_name_slug):
    
    context_dict = {'category_name_slug': category_name_slug}
        
    try:
        
        category = Category.objects.get(slug = category_name_slug)
        
        context_dict['category_name'] = category.name
        
        pages = Page.objects.filter(category = category)
        
        context_dict['pages'] = pages
        
        context_dict['category'] = category
        
    except Category.DoesNotExist:
        my_str = category_name_slug.split('-')
        context_dict['category_name'] = ' '.join([i.capitalize() for i in my_str])
        
    result_list = []
    query = ''
    
    if request.method == 'POST':
        if request.POST.get('query', False):
            query = request.POST['query'].strip()
        
        if query:
            result_list = run_query(query)
            
    context_dict['result_list'] = result_list
    context_dict['query'] = query
        
    
    return render(request, 'rango/category.html', context_dict)

def category(request, category_name_slug):

    context_dict = {}
    
    try:
        
        category = Category.objects.get(slug=category_name_slug)
        context_dict['category_name'] = category.name
        
        pages = Page.objects.filter(category= category)
        
        context_dict['pages'] = pages
        
        context_dict['category'] = category
        
        context_dict['slug'] = category_name_slug
        
        context_dict['results'] = []
    
        if request.method =='POST':
            query = request.POST['query'].strip()
        
            if query:
        
                context_dict['results'] = run_query(query)
    
    except Category.DoesNotExist:
        pass
        
    return render(request, 'rango/category.html', context_dict)

def category(request, category_name_url):
	# REquest our context from the request passed to us
	context = RequestContext(request)
	category_name = category_name_url.replace('_',' ')
	context_dict = {'category_name':category_name}
	context_dict['cats'] = get_category_list()
	try: 
		category = Category.objects.get(name=category_name)
		pages = Page.objects.filter(category=category) #Get the corresponding pages for the Category Object)\
		context_dict['pages'] = pages   #Adding the pages to the dict
		context_dict['category']= category   #Adding the category to dict to check the category in the template
		context_dict['category_name_url']= category_name_url
	except Category.DoesNotExist:
		pass
	
	#Search Functionality
	result_list = []
	if request.method == 'POST':
		query = request.POST['query'].strip()
		if query:
			result_list = run_query(query)
	context_dict['cats']=get_category_list()
	context_dict['result_list'] = result_list
	
	return render_to_response('rango/category.html', context_dict, context)

def category(request, category_name_slug):

    context_dict = {}
    context_dict['result_list'] = None
    context_dict['query'] = None
    if request.method == 'POST':

    #Using try here cause page is expected search POST
    #But sometimes gets a re-direct from add_page causing this to break
        try:
            query = request.POST['query'].strip()

            if query:
                # Run our Bing function to get the results list!
                result_list = run_query(query)

                context_dict['result_list'] = result_list
                context_dict['query'] = query
        except:
            pass

    try:
        category = Category.objects.get(slug=category_name_slug)
        context_dict['category_name'] = category.name
        pages = Page.objects.filter(category=category).order_by('-views')
        context_dict['pages'] = pages
        context_dict['category'] = category
    except Category.DoesNotExist:
        pass

    if not context_dict['query']:
        context_dict['query'] = category.name

    return render(request, 'rango/category.html', context_dict)

def category(request, category_name_url):


    context = RequestContext(request)
    category_name = endecode(category_name_url)
    category_list = get_5_categories()

    context_dict = {'category_name': category_name, 'category_name_url': category_name_url, 'categories': category_list}

    try:

        category = Category.objects.get(name=category_name)
        context_dict['category'] = category

        pages = Page.objects.filter(category=category).order_by('-views')
        context_dict['pages'] = pages

    except Category.DoesNotExist:
        pass


    if request.method == 'POST':
        if 'query' in request.POST:
            query = request.POST['query'].strip()
            print query

            if query:
                result_list = run_query(query)
                print result_list
                context_dict['result_list'] = result_list


    # Go render the response and return it to the client.
    return render_to_response('rango/category.html', context_dict, context)

def category(request, category_name_url):
    context = RequestContext(request)
    cat_list = get_category_list()
    category_name = decode_url(category_name_url)

    context_dict = {'cat_list': cat_list, 'category_name': category_name, 'category_name_url': category_name_url}

    try:
        category = Category.objects.get(name=category_name)
    
        # Add category to the context so that we can access the id and likes
        context_dict['category'] = category
    
        pages = Page.objects.filter(category=category)
        context_dict['pages'] = pages
    except Category.DoesNotExist:
        pass
    
    if request.method == 'POST':
        print "IN POST"
        query = request.POST.get('query')
        if query:
            query = query.strip()
            result_list = run_query(query)
            context_dict['result_list'] = result_list

    return render_to_response('rango/category.html', context_dict, context)

def category(request, category_name_slug):
    context_dict = { 'query': None, 'result_list': None }

    if request.method == "POST":
        query = request.POST['query'].strip()
        if query:
            context_dict['query'] = query
            context_dict['result_list'] = run_query(query)

    try:
        cat = Category.objects.get(slug=category_name_slug)
        context_dict['category_name'] = cat.name
        context_dict['category_name_slug'] = category_name_slug

        pages = Page.objects.filter(category=cat).order_by('-views')

        context_dict['pages'] = pages
        context_dict['category'] = cat
    except Category.DoesNotExist:
        context_dict['category_name'] = category_name_slug

    if not context_dict['query']:
        context_dict['query'] = cat.name

    return render(request, 'rango/category.html', context_dict)

def category(request, category_name_url):
    context = RequestContext(request)

    category_name = decode_url(category_name_url)
    cat_list = get_category_list()

    context_dict = {"category_name": category_name, "category_name_url": category_name_url, "cat_list": cat_list}

    try:
        category = Category.objects.get(name__iexact=category_name)

        pages = Page.objects.filter(category=category).order_by("-views")

        context_dict["pages"] = pages

        context_dict["category"] = category

    except Category.DoesNotExist:
        pass

    if request.method == "POST":
        query = request.POST.get("query")
        if query:
            query = query.strip()
            result_list = run_query(query)
            context_dict["result_list"] = result_list

    return render_to_response("rango/category.html", context_dict, context)

def category(request, category_name_url):
    context = RequestContext(request)
    # Replace undrescores in ulr to spaces
    category_name = decode_category_name(category_name_url)
    category_list = get_category_list()
    context_dict = {'category_name': category_name, 'categories': category_list,}
    if request.method == "POST":
        query = request.POST['query'].strip()
        if query:
            result_list = run_query(query)
            context_dict['result_list'] = result_list


    try:
        category = Category.objects.get(name=category_name)
        # return pages associated to the category
        pages = Page.objects.filter(category=category)
        # Add category to context dictionary to verify category exists
        context_dict['category'] = category
        context_dict['pages'] = pages
        context_dict['category_name_url'] = category_name_url

    except Category.DoesNotExist:
        # Template will display "Does not exist" message
        pass

    return render_to_response('rango/category.html', context_dict, context)

def category(request, category_name_slug):
    result_list = None
    query = None
    if request.method == 'POST':
        query = request.POST['query'].strip()

        if query:
            # Run our Bing function to get the results list!
            result_list = run_query(query)
    try:
        # Can we find a category name slug with the given name?
        # If we can't, the .get() method raises a DoesNotExist exception.
        # So the .get() method returns one model instance or raises an exception.
        category = Category.objects.get(slug=category_name_slug)
        category_name = category.name
        # Retrieve all of the associated pages.
        # Note that filter returns >= 1 model instance.
        pages = Page.objects.filter(category=category).order_by('-views')
    except Category.DoesNotExist:
        # We get here if we didn't find the specified category.
        # Don't do anything - the template displays the "no category" message for us.
        pass
    
    if not query:
        assert isinstance(category.name, object)
        query = category.name

    return render(request, 'rango/category.html', {'category': category, 'category_name': category_name,
                                                   'pages': pages, 'category_name_slug': category_name_slug,
                                                   'result_list': result_list, 'query': query})

def category(request, category_name_slug):

    #Create a blank dict for the rendering engine
	context_dict = {}

	if request.method == 'POST':
		query = request.POST['query'].strip()

		if query:

			#run the bing search function
			result_list = run_query(query)

		return render(request, 'rango/search.html', {'result_list': result_list})

	else:

		try:
	        #find the category that matches the slug url
			category = Category.objects.get(slug=category_name_slug)
			context_dict['category_name'] = category.name
			print category
			pages = Page.objects.filter(category=category)

			context_dict['pages'] = pages
			context_dict['category'] = category

		except Category.DoesNotExist:
	        #If nothing is found
			pass
	#Render it up
	return render(request, 'rango/category.html', context_dict)

def category(request, category_name_url):
    # Request our context from the request passed to us.
    context = RequestContext(request)

    # Change underscores in the category name to spaces.
    # URLs don't handle spaces well, so we encode them as underscores.
    # We can then simply replace the underscores with spaces again to get the name.
    category_name = decode_url(category_name_url)

    # Create a context dictionary which we can pass to the template rendering engine.
    # We start by containing the name of the category passed by the user.
    context_dict = {'category_name': category_name, 'category_name_url': category_name_url}

    cat_list = get_category_list()
    context_dict['cat_list'] = cat_list

    try:
        category = Category.objects.get(name__iexact=category_name)
        context_dict['category'] = category
        pages = Page.objects.filter(category=category).order_by('-views')
        context_dict['pages'] = pages

    except Category.DoesNotExist:
        pass

    if request.method == 'POST':
        query = request.POST.get('query')
        if query:
            query = query.strip()
            result_list = run_query(query)
            context_dict['result_list'] = result_list

    # Go render the response and return it to the client.
    return render_to_response('rango/category.html', context_dict, context)