def new(request):
    review = Review()
    if request.method == 'POST':
        title = request.POST['title']
        description = request.POST['description']
        author = request.user
        name = slugify(title)
        unique_name = name
        i = 0
        while Review.objects.filter(name=unique_name, author__username=request.user.username):
            i = i + 1
            unique_name = name + '-' + str(i)
        
        review = Review(name = unique_name, title = title, description = description, author=author)

        is_valid = True
        if not title:
            is_valid = False
            messages.add_message(request, messages.ERROR, 'Title is a required field.')
        elif len(title) > 250:
            is_valid = False
            messages.add_message(request, messages.ERROR, 'The title should not exceed 250 characters.')
        if len(description) > 500:
            is_valid = False
            messages.add_message(request, messages.ERROR, 'The description should not exceed 500 characters.')

        if is_valid:
            review.save()
            messages.add_message(request, messages.SUCCESS, 'Review created with success.')
            return redirect('/' + review.author.username + '/' + review.name + '/')

    context = RequestContext(request, {'review': review})
    return render_to_response('reviews/new.html', context)

def extract_review_from_row(review_row):
    review = Review(id = review_row["id"],
                    author = review_row["username"],
                    item = Item.objects.get(id=review_row["item_id"]),
                    rating = review_row["rating"],
                    review = review_row["comment"],
                    pub_date = datetime.datetime.now()
                    )
    review.save()

def save_review_from_row(review_row):
    review = Review()
    review.id = review_row[0]
    review.user_name = review_row[1]
    review.wine = Wine.objects.get(id=review_row[2])
    review.rating = review_row[3]
    review.pub_date = datetime.datetime.now()
    review.comment = review_row[4]
    review.save()

def create_reviews(user, business):
    reviews = []

    review = Review.create(user.id, business, 1, 'This is not good.', tags=['hello', 'world'])
    reviews.append(review)

    review = Review.create(user.id, business, 1, 'This is also not good.', tags=['hello', 'example'])
    reviews.append(review)

    review = Review.create(user.id, business, 5, 'This is awesome.', tags=['awesome'])
    reviews.append(review)

    return reviews

def save_review_from_row(review_row):
	review = Review()
	review.id = review_row[0]
	review.user_name = review_row[1]
	# This can be an error if you gave not imported the wines yet
	review.wine = Wine.objects.get(id=review_row[2])
	review.rating = review_row[3]
	review.pub_date = datetime.datetime.now()
	review.comment = review_row[4]
	review.save()

 def create_review(self, commit=True):
     review = Review(product=self.product)
     review.rating = self.data['rating']
     review.summary = self.data['summary']
     review.review = self.data['review']
     review.user = self.request.user
     if commit:
         review.full_clean()
         review.save()
     return review

def get_rotten_tomates():
	for movie in Movie.objects.all():
		if len(RT('bt7f4pcbku6m9mqzuhhncc9e').search(movie.name))==0:
			break
		movie_id=RT('bt7f4pcbku6m9mqzuhhncc9e').search(movie.name)[0]['id']
		for j in range(len(RT('bt7f4pcbku6m9mqzuhhncc9e').info(movie_id, 'reviews')['reviews'])):
							reviewblob = RT('bt7f4pcbku6m9mqzuhhncc9e').info(movie_id, 'reviews')['reviews']
							quote=reviewblob[j]['quote']
							fresh_bool='fresh' in reviewblob[j]['freshness']
							name= reviewblob[j]['critic']
							print(quote)
							print(name)
							review= Review(name=name, body=quote, fresh=fresh_bool, movie=movie)
							review.save()

def save_review_from_row(review_row):
    review=Review()
    review.id=review_row[0]
    review.user_name=review_row[1]
    # we use the wine id to look for the wine instance
    # this means that we need to load wines before we load reviews
    review.wine=Wine.objects.get(id=review_row[2])
    review.rating=review_row[3]
    review.pub_date=datetime.datetime.now()
    review.comment=review_row[4]
    review.save()

    def reset(self):
        for _id in self.created_ids:
            review = Review.get_by_id(_id)
            review.delete()

        self.user.delete()
        self.business.delete()

def update_business(event):
    """
    compiles rating and tags for a business when a review is updated
    """
    from reviews.models import Review

    review = event.review
    business = Business.get_by_id(review.reviewed_id)

    if business:
        business.rating = Review.rating_for_reviewed(review.reviewed_id)
        business.tags = Review.tags_for_reviewed(review.reviewed_id)
        business.save()
        logger.debug('updated business:{} reviews'.format(business.id))
    else:
        logger.debug('failed to update business:{} reviews'.format(review.reviewd_id))

def review_list(request, addon, review_id=None, user_id=None, rating=None):
    qs = Review.objects.valid().filter(addon=addon).order_by('-created')

    ctx = {'product': addon, 'score': rating, 'review_perms': {}}

    if review_id is not None:
        qs = qs.filter(pk=review_id)
        ctx['page'] = 'detail'
        # If this is a dev reply, find the first msg for context.
        review = get_object_or_404(Review, pk=review_id)
        if review.reply_to_id:
            review_id = review.reply_to_id
            ctx['reply'] = review
    elif user_id is not None:
        qs = qs.filter(user=user_id)
        ctx['page'] = 'user'
        if not qs:
            raise http.Http404()
    else:
        ctx['page'] = 'list'
        qs = qs.filter(is_latest=True)

    ctx['ratings'] = ratings = amo.utils.paginate(request, qs, 20)
    if not ctx.get('reply'):
        ctx['replies'] = Review.get_replies(ratings.object_list)
    if request.user.is_authenticated():
        ctx['review_perms'] = {
            'is_admin': acl.action_allowed(request, 'Addons', 'Edit'),
            'is_editor': acl.check_reviewer(request),
            'is_author': acl.check_addon_ownership(request, addon, viewer=True,
                                                   dev=True, support=True),
        }
        ctx['flags'] = get_flags(request, ratings.object_list)
        ctx['has_review'] = addon.reviews.filter(user=request.user.id).exists()
    return jingo.render(request, 'ratings/listing.html', ctx)

    def reviews_post(request):
        """
        creates new business review

        **authentication required with access_token**


        errors
        ======

        * status 400 - if failed to create business


        returns
        =======

        ::

            {
                "id": ""
            }
        """
        business_id = request.matchdict['business_id']
        business = Business.get_by_id(business_id)
        user = request.validated['user']
        text = request.validated['text']
        rating = request.validated['rating']
        tags = request.validated['tags']

        if tags:
            tags = tags.split(':')
        else:
            tags = []

        if business and user:
            review = Review.create(user.id, business, rating, text, tags)
            response_body = {
                'id': review.id,
            }

            # kill cache
            cache_key = 'business:{}*'.format(business.id)
            redis_cache.delete_pattern(cache_key)
        else:
            logger.debug('Failed to create review for business:{}'.format(business_id))
            request.response.status_int = 400
            response_body = {
                'status': 'error',
                'message': 'failed to create review for business'
            }

        request.response.body = json.dumps(response_body, cls=ComplexEncoder)
        request.response.content_type = 'application/json'
        return request.response

    def test_reviews(self):
        review = Review.create(self.user.id, self.business, 1, 'This is a review', tags=['hello', 'world'])
        self.created_ids.append(review.id)

        review = Review.create(self.user.id, self.business, 5, 'This is a another review', tags=['hello', 'something'])
        self.created_ids.append(review.id)

        self.business = Business.get_by_id(self.business.id)
        self.assertTrue(self.business.rating == 3)
        self.assertTrue('hello' in self.business.tags)
        self.assertTrue('world' in self.business.tags)
        self.assertTrue('something' in self.business.tags)

        review.delete()
        self.business = Business.get_by_id(self.business.id)
        self.assertTrue(self.business.rating == 1)
        self.assertFalse('something' in self.business.tags)

        review = Review.create(self.user.id, self.business, 5, 'This is a another review', tags=['hello', 'something'])
        self.created_ids.append(review.id)

def write_review_view(request, product_slug):
    product = Product.objects.filter(slug=product_slug).first()

    review_form = ReviewForm(request.POST or None)

    if request.method == 'POST':
        if review_form.is_valid():
            title = review_form.cleaned_data['title']
            body = review_form.cleaned_data['body']
            score = review_form.cleaned_data['score']

            new_review = Review(user = request.user , product = product , title=title, body=body, score=score)
            new_review.save()

            return redirect('product_view', product_slug=product_slug)

    context = {
        'product': product,
        'review_form': review_form,
    }
    return render(request, 'products/write_review.html', context)

    def reviews_get(request):
        """
        Returns the business reviews


        errors
        ======

        * status 404 - if the business can't be found


        returns
        =======

        ::

            {
                "reviews": [
                    {
                        "rating": 5,
                        "modified": "2015-08-10T00:20:17.753000",
                        "id": "55c7ee41fad9b43993d71919",
                        "user_id": "55c7ee3dfad9b43993d7190e",
                        "reviewed_id": "55c7ee3efad9b43993d7190f",
                        "tags": [
                            "awesome"
                        ],
                        "text": "This is awesome.",
                        "created": "2015-08-10T00:20:17.753000",
                        "reviewed_collection": "businesses"
                    }
                ]
            }
        """
        business_id = request.matchdict['business_id']
        business = Business.get_by_id(business_id)

        if business:
            response_body = {
                'reviews': Review.reviews_for_reviewed(business.collection, business.id)
            }
            logger.debug('Retrieved business:{} reviews'.format(business.id))
        else:
            logger.debug('Failed to retrieve business:{} reviews'.format(business_id))
            request.response.status_int = 404
            response_body = {
                'status': 'error',
                'message': 'failed to find business'
            }

        request.response.body = json.dumps(response_body, cls=ComplexEncoder)
        request.response.content_type = 'application/json'
        return request.response

def create_review(request):
	if request.method == 'POST':
		print "Received POST"
		try:
			rating = request.POST['rating']
			course = request.POST['course']
			author = request.POST['author']
			professor = request.POST['professor']
			rating = int(request.POST['rating'])
			text = request.POST['text']

			if rating >= 1 and rating <= 5:
				courseobj = None

				try:
					courseobj = Course.objects.get(coursename=course)
				except Course.DoesNotExist:
					courseobj = Course(coursename=course)
					courseobj.save()

				r = Review(course=courseobj, author=author, professor=professor, score=rating, text=text)
				r.save()

				print "Saved %s" % r

				return HttpResponseRedirect(reverse('course_reviews', args=(course,)))
			else:
				raise ValueError()
		except:
			context = { 'error_message': "Please fill all fields",
						'course': 	 course,
						'author': 	 author,
						'professor': professor,
						'rating': 	 rating,
						'text': 	 text }
			return render(request, 'reviews/create_review.html', context)
	else:
		return render(request, 'reviews/create_review.html', None)

    def review_get(request):
        """
        Returns the business review


        errors
        ======

        * status 404 - if the review couldn't be found


        returns
        =======

        ::

            {
                "rating": 5,
                "modified": "2015-08-10T00:20:17.753000",
                "id": "55c7ee41fad9b43993d71919",
                "user_id": "55c7ee3dfad9b43993d7190e",
                "reviewed_id": "55c7ee3efad9b43993d7190f",
                "tags": [
                    "awesome"
                ],
                "text": "This is awesome.",
                "created": "2015-08-10T00:20:17.753000",
                "reviewed_collection": "businesses"
            }
        """
        business_id = request.matchdict['business_id']
        review_id = request.matchdict['review_id']
        business = Business.get_by_id(business_id)
        review = Review.get_by_id(review_id)

        if business and review and business.id == review.reviewed_id:
            response_body = review.json
            logger.debug('Retrieved business:{} review:{}'.format(business.id, review.id))
        else:
            logger.debug('Failed to retrieve business:{} review:'.format(business_id, review_id))
            request.response.status_int = 404
            response_body = json.dumps({
                'status': 'error',
                'message': 'failed to find business review'
            })

        request.response.body = response_body
        request.response.content_type = 'application/json'
        return request.response

def new_review(request, slug, format=None):
    """Create new review for tutor."""
    profile = get_object_or_404(Profile, slug=slug)
    if request.method == 'POST':
        content = request.POST.get('content')
        # If current user is tutee and profile user is tutor and content
        if request.user.profile.tutee and profile.tutor and content:
            if request.POST.get('positive'):
                if int(request.POST.get('positive')):
                    positive = True
                else:
                    positive = False
            review          = Review()
            review.content  = content
            review.positive = positive
            review.tutee    = request.user
            review.tutor    = profile.user
            review.save()
            if format:
                if format == '.js':
                    d = {
                        'review': review,
                        'static': settings.STATIC_URL,
                        'userd': profile.user,
                    }
                    new_review_form = loader.get_template(
                        'reviews/new_review_form.html')
                    review_template = loader.get_template(
                        'reviews/review.html')
                    context = RequestContext(request, add_csrf(request, d))
                    data = {
                        'new_review_form': new_review_form.render(context),
                        'review_template': review_template.render(context),
                    }
                elif format == '.json':
                    data = {
                        'review': review.to_json(),
                    }
                return HttpResponse(json.dumps(data), 
                    mimetype='application/json')
            else:
                messages.success(request, 'Review submitted')
    return HttpResponseRedirect(reverse('users.views.detail',
        args=[profile.slug]))

def add_review(request, game_id):
    game = get_object_or_404(Game, pk=game_id)
    form = ReviewForm(request.POST)
    if form.is_valid():
        rating = form.cleaned_data['rating']
        comment = form.cleaned_data['comment']
        user_name = request.user.username
        review = Review()
        review.game = game
        review.user_name = user_name
        review.rating = rating
        review.comment = comment
        review.pub_date = datetime.datetime.now()
        review.save()
        """Always return an HttpResponseRedirect after successfully dealing
        with POST data. This prevents data from being posted twice if a
        user hits the Back button."""
        return HttpResponseRedirect(reverse('game_detail', args=(game.id,)))

    return render(request, 'game_detail.html', {'game': game, 'form': form})

def create_review(request, trail_id):
    if request.method == 'POST':
        if request.user.is_authenticated():
            if request.POST.get('review_text') != '':
                review = Review()
                review.review_text = request.POST.get('review_text')
                review.user = request.user
                review.trail = get_object_or_404(Trail, pk=trail_id)
                review.save()
                return HttpResponseRedirect('/trail/%s' % str(trail_id))
            else:
                messages.add_message(request, messages.WARNING, 'No comment text was provided')
                return HttpResponseRedirect('/trail/%s/' % str(trail_id))
                
    return render(request, 'trails/create_review.html', {'trail_id':trail_id, 'form':form})