Example #1
0
def add_rating(request, profID):
	if request.method == 'POST':
		form = RatingForm(request.POST)
		if form.is_valid():
			rating = Rating()
			rating.professor = Professor.objects.get(id=profID)
			rating.poster = request.user
			rating.overall = form.cleaned_data['overall']
			rating.humor = form.cleaned_data['humor']
			rating.difficulty = form.cleaned_data['difficulty']
			rating.availability = form.cleaned_data['availability']
			if Rating.objects.filter(poster=request.user).filter(professor=rating.professor).count > 0:
				params = {
					'message': 'You cannot rate a professor multiple times',
				}
				return render(request, 'message.html', params)
			rating.save()
		return HttpResponseRedirect('/accounts/profs/profID/' + profID + '/')
	else:
		form = RatingForm()
		prof = Professor.objects.get(id=profID)
		params = {
			'form': form,
			'formTitle': 'Add a rating for ' + str(prof.firstName) + ' ' + str(prof.lastName),
		}
		return render(request, 'profSearch.html', params)
Example #2
0
def api_add_rating(request, course_id):
    if request.method == 'POST':
        form = RatingForm(request.POST)
        results = []

        if form.is_valid():
            rating = form.save(commit=False)
            rating.user = UserProfile.objects.get(user=int(request.user.id))
            rating.date = datetime.datetime.now()
            try:
                c = Course.objects.get(id=int(course_id))
                rating.course = c
                rating.save()

                #update the course averages
                c.number_of_ratings += 1
                c.average_difficulty = ((c.average_difficulty if c.average_difficulty else 0) * (
                    c.number_of_ratings - 1) + Decimal(form.cleaned_data['difficulty_rating'])) \
                                       / Decimal(c.number_of_ratings)

                c.average_teaching = ((c.average_teaching if c.average_teaching else 0) * (
                    c.number_of_ratings - 1) + Decimal(form.cleaned_data['teaching_rating'])) \
                                     / Decimal(c.number_of_ratings)

                c.average_materials = ((c.average_materials if c.average_materials else 0) * (c.number_of_ratings - 1) +
                                       Decimal(form.cleaned_data['materials_rating'])) / Decimal(c.number_of_ratings)

                c.average_overall = ((c.average_overall if c.average_overall else 0) * (
                    c.number_of_ratings - 1) + Decimal(form.cleaned_data['overall_rating'])) \
                                    / Decimal(c.number_of_ratings)

                c.average_satisfaction = ((c.average_satisfaction if c.average_satisfaction else 0) * (
                    c.number_of_ratings - 1) + Decimal(form.cleaned_data['satisfaction_rating'])) \
                                         / Decimal(c.number_of_ratings)

                c.save()

                #response contains averages for the course, and the username of the submitter
                msg = {"data": {
                    "overall": float(c.average_overall),
                    "satisfaction": float(c.average_satisfaction),
                    "difficulty": float(c.average_difficulty),
                    "teaching": float(c.average_teaching),
                    "materials": float(c.average_materials),
                    "ratings": c.number_of_ratings,
                    "username": request.user.username
                }
                }
                results.append(msg)
            except Exception as e:
                return HttpResponseRedirect('/')
        else:
            print form.errors
            errors = {"errors": form.errors
            }
            results.append(errors)
        return HttpResponse(json.dumps(results), content_type="application/json")

    else:
        return course(request, course_id)
Example #3
0
def edit_rating():
    conn = mysql.connector.connect(**config)
    c = conn.cursor(buffered=True)
    if request.method == "GET":
        form = RatingForm()
        c.execute("SELECT * FROM Rating")
        rating = c.fetchall()
        return render_template('edit_rating.html',
                               title='edit_rating',
                               rating=rating,
                               form=form)

    elif request.method == 'POST':
        form = RatingForm(request.form)
        uid = request.form.get("uid")
        rid = request.form.get('rid')
        #comment = request.form.get('comment')
        stars = request.form.get('stars')
        c.execute("SELECT * FROM Rating R WHERE R.rid=" + (rid))
        #results = c.fetchall()

        query = "UPDATE Rating SET Stars = " + str(stars) + ", Uid = " + str(
            uid) + " WHERE rid= " + str(rid)
        c.execute(query)
        conn.commit()

        flash(f'Rating has been edited!.', 'success')
        return redirect(url_for('rating'))
Example #4
0
def rate(id_val):
    form = RatingForm(request.form)
    if request.method == 'POST' and form.validate():
        movieId = id_val
        audienceId = current_user.get_id()
        rating = form.rating.data
        add_rating(db, movieId, audienceId, rating)
        flash('Rating successfully entered.')
        return redirect(url_for('show_movie_info',id_val= id_val))
    return render_template('Rating_page.html', form=form)
Example #5
0
    def test_form_fails_with_invalid_data(self):
        """Test that form will fail if given invalid data."""

        form_data = {
            'score': 11,
            'beer_name': "Test Beer",
            'brewer_name': "Test Co",
            'notes': "Test Notes"
        }
        form = RatingForm(data=form_data)
        self.assertFalse(form.is_valid())
Example #6
0
def process_rating(request):
    if request.method == "POST":
        form = RatingForm(request.POST)
        if form.is_valid():
            practice_item = get_object_or_404(FlashCard,
                                              pk=int(form.cleaned_data['id']))
            practice_item.set_next_practice(int(form.cleaned_data['rating']))
            practice_item.save()

            return redirect(to='list_flashcards')
    else:
        return HttpResponseBadRequest("There's nothing here. Haha.")
Example #7
0
def process_rating(request):
    if request.method == "POST":
        form = RatingForm(request.POST)
        if form.is_valid():
            practice_item = get_object_or_404(FlashCard,
                                              pk=int(form.cleaned_data['id']))
            practice_item.set_next_practice(int(form.cleaned_data['rating']))
            practice_item.save()

            return redirect(to='list_flashcards')
    else:
        return HttpResponseBadRequest("There's nothing here. Haha.")
Example #8
0
def create_and_save_rating():
    """Creates a new rating and saves it in the database."""

    form_data = {
        'score': 9,
        'beer_name': "Test Beer",
        'brewer_name': "Test Co",
        'notes': "Test Notes"
    }
    form = RatingForm(data=form_data)
    rating = form.save()

    return rating
Example #9
0
def identify():
    form = RatingForm()
    if form.validate_on_submit():
        rating = form.rating.data
        print session['user_id'], 1, rating
        cur = mysql.connection.cursor()
        cur.execute("INSERT INTO user_article VALUES(%s, %s, %s)",
                    (session['user_id'], 1, rating))
        mysql.connection.commit()
        cur.close()
        flash('Rating is submitted for this article', 'success')
        return redirect(url_for('identify'))

    return render_template('identify.html', form=form)
Example #10
0
    def test_form_data_is_valid(self):
        """Test that rating form is working."""

        form_data = {
            'score': 9,
            'beer_name': "Test Beer",
            'brewer_name': "Test Co",
            'notes': "Test Notes"
        }
        form = RatingForm(data=form_data)
        self.assertTrue(form.is_valid())
        rating = form.save()
        self.assertEqual(rating.score, 9)
        self.assertEqual(rating.beer_name, "Test Beer")
        self.assertEqual(rating.brewer_name, "Test Co")
        self.assertEqual(rating.notes, "Test Notes")
Example #11
0
def edit_rating():
    if request.method=="GET":
        form = RatingForm()
        conn = mysql.connector.connect(**config) 
        conn.row_factory = dict_factory
        c = conn.cursor()
        c.execute("SELECT * FROM Rating")            
        rating = c.fetchall()
        return render_template('edit_rating.html', title='edit_rating', form=form) 
Example #12
0
def demo_rate(request, demoid):
    context = RequestContext(request)
    context_dict ={}
    t = get_team(request.user)
    add_isteam_to_context_dict(context_dict, t)

    rater = get_rater(request.user)

    if rater:
        if request.method == 'POST':
            rating_form = RatingForm(data=request.POST)
            if rating_form.is_valid():
                demo = Demo.objects.get(id=demoid)

                # check if the rater has already rated this app, if so, remove this entry and replace with new rating
                rating_check = Rating.objects.filter(rater=rater,demo=demo).count()
                if rating_check == 1:
                    past_rating = Rating.objects.get(rater=rater,demo=demo)
                    demo.rating_count = demo.rating_count - 1
                    demo.rating_sum = demo.rating_sum - past_rating.score
                    past_rating.delete()
                    demo.save()

                rating = rating_form.save(commit=False)
                rating.rater = rater
                rating.demo = demo
                rating.save()
                demo.rating_count = demo.rating_count + 1
                demo.rating_sum = demo.rating_sum + rating.score
                demo.save()

                return HttpResponseRedirect('/showcase/demo/show/'+str(demoid)+'/')
            else:
                print rating_form.errors
        else:
            rating_form = RatingForm()

            context_dict['rating_form']=rating_form
            return render_to_response(
            'showcase/demo.html',
            context_dict,
            context)

    return HttpResponseRedirect('/showcase/demo/show/'+str(demoid)+'/')
Example #13
0
def rate_show():
    form = RatingForm(request.form)
    if request.method == 'POST' and form.validate():
        # Check if the rater is a buyer
        cnx = mysql.connector.connect(user='******',
                                      password='******',
                                      host='104.197.213.149',
                                      database='wgzzdb')
        cursor = cnx.cursor()
        checker = "SELECT BuyerSSN FROM Buyers WHERE BuyerSSN = " + str(
            form.data['ssn']) + ";"
        cursor.execute(checker)
        results = cursor.fetchall()
        if not results:
            flash('Not eligible to rate!')
            return redirect('/')

        # Check if the rater's name and SSN match
        checker = "SELECT BuyerSSN, BuyerName FROM Buyers WHERE BuyerSSN = " + str(
            form.data['ssn']
        ) + " AND BuyerName = " + "'" + form.data['name'] + "';"
        cursor.execute(checker)
        results = cursor.fetchall()
        if not results:
            flash('Name and SSN did not match!')
            return redirect('/')

        # Add a piece of rating info
        date = datetime.today()
        rating = dict(RatingForm.rate).get(form.rate_choice.data)
        query = "INSERT INTO Rating (BuyerSSN, ShowName, Rating, RatingDate) VALUES (%s, %s, %s, %s)"
        val = (form.data['ssn'], form.data['show'], int(rating), date)
        cursor.execute(query, val)

        cnx.commit()

        cursor.close()
        cnx.close()

        flash('Rate successful!')
        return redirect('/')

    return render_template('rate_show.html', form=form)
Example #14
0
def home():
    form = RatingForm()
    # def clean_text(text):
    #     text = text.lower()
    #     clean = re.compile('<.*?>')
    #     text = re.sub(clean,'',text)
    #     text = re.sub(r"""[,.;@#?!&$]+\ *"""," ",text, flags=re.VERBOSE)
    #     text = text.replace('\r\n', '-').replace('\n', ' ')
    #     check = text.replace(" ", "").isalpha()
    #     if check:
    #         text = [word for word in word_tokenize(text)]
    #     else:
    #         text = [word for word in word_tokenize(text) if word.isalpha()]        
    # return text
    # def stem(text):
    #     text = ' '.join([porter.stem(word) for word in text.split()])
    # return text
    if form.validate_on_submit():
        review = form.review.data
        #review = clean_text(review)
        review = review.lower()
        clean = re.compile('<.*?>')
        review = re.sub(clean,'',review)
        review = re.sub(r"""[,.;@#?!&$]+\ *"""," ",review, flags=re.VERBOSE)
        review = review.replace('\r\n', '-').replace('\n', ' ')
        review = [word for word in review.split() if word.isalpha()]
        STOPWORDS= set(["a","about","above","after","again","against","am","an","and","any","are","as","at","be","been","before","being","below","between","both","by","can","could","did","do","does","doing","down","during","each","few","for","from","further","had","has","have","having","he","he'd","he'll","he's","her","here","here's","hers","herself","him","himself","his","how","how's","i","i'd","i'll","i'm","i've","in","into","is","isn't","it","it's","its","itself","let's","me","more","myself","of","off","on","once","only","or","other","ought","our","ours" ,"ourselves","out","over","own","same","she","she'd","she'll","she's","should","so","some","such","than","that","that's","the","their","theirs","them","hemselves","then","there","there's","these","they","they'd","they'll","they're","they've","this","those","through","to","too","under","until","up","very","was","we","we'd","we'll","we're","we've","were","what","what's","when","when's","where","where's","which","while","who","who's","whom","why","why's","with","would","you","you'd","you'll","you're","you've","your","yours","yourself","yourselves","return","hes","heres","hows","im","its","lets","shes","thats","theres","theyll","theyre","theyve","were","whats","whens","wheres","whos","whys","youd","youll","youre","youve"])
        STOPWORDS_dict = dict.fromkeys(STOPWORDS, 0)
        review = [word for word in review if word not in STOPWORDS_dict]
        review = ' '.join(word for word in review)
        # porter=PorterStemmer()
        # review = ' '.join([porter.stem(word) for word in review.split()])
        vocab = open('models/Vocab.pickle', 'rb')      
        vocab_pickled = pickle.load(vocab) 
        vectorizer = TfidfVectorizer(vocabulary=vocab_pickled.vocabulary_)
        model = open('models/LinearRegression.pickle', 'rb')      
        linearregression_pickled = pickle.load(model) 
        p = vectorizer.fit_transform([review])
        rate = round(linearregression_pickled.predict(p)[0],2)
        flash(f'YOUR REVIEW : {review}','success')
        flash(f'MY MODEL RATING : { rate }','success')
        return redirect(url_for('predict'))
    return render_template('PredictReviewRating.html',form=form)
Example #15
0
def movie_rating(id):
    form = RatingForm()
    movie = mg.db.movie.find_one({'_id': id})
    form.uid.data = current_user.uid
    form.mid.data = movie['lens_id']
    form.name.data = movie['title']
    if form.validate_on_submit() and request.method == 'POST':
        Rating(uid=int(form.uid.data),
               mid=int(form.mid.data),
               name=form.name.data,
               rating=float(form.rating.data),
               title=form.title.data,
               content=form.content.data).save()
        recommender.add_ratings(
            [[int(form.uid.data),
              int(form.mid.data),
              float(form.rating.data)]])
        flash('rating recorded, retraining model...')
        return redirect(url_for('main.movie_rating', id=id))
    return render_template('rating.html', movie=movie, form=form)
Example #16
0
    def test_edit_rating(self):
        """Test that edit rating feature is working by checking database values before and after edit of beer name."""

        rating = create_and_save_rating()
        rating_in_db = Rating.objects.filter(pk=rating.pk).exists()
        self.assertEqual(rating.beer_name, "Test Beer")

        response = self.client.post(reverse('rating_edit', args=(rating.pk, )))

        form_data = {
            'score': 9,
            'beer_name': "Testing Edit",
            'brewer_name': "Test Co",
            'notes': "Test Notes"
        }
        form = RatingForm(data=form_data)
        self.assertTrue(form.is_valid())
        rating = form.save()

        self.assertEqual(rating_in_db, True)
        self.assertEqual(rating.beer_name, "Testing Edit")
        self.assertEqual(response.status_code, 200)
Example #17
0
def course(request, course_id):
    context = RequestContext(request)
    form = RatingForm(request.GET)
    if request.user.is_authenticated():
        submitted = Rating.objects.filter(
            course=Course.objects.get(id=int(course_id)),
            user=UserProfile.objects.get(user=int(request.user.id))).exists()
    else:
        submitted = False
    try:
        c = Course.objects.get(id=int(course_id))
        c.hit()
        c.save()
        ratings = Rating.objects.all().filter(course=int(course_id))
    except:
        #course doesnt exist? Back to homepage then
        return HttpResponseRedirect('/')

    return render_to_response('course.html', locals(), context)
Example #18
0
def home(request):
    # scrape_imdb()
    u = request.user
    rated_items = UserRating.objects.filter(corresponding_user=u)
    movies = Movie.objects.all()
    name_to_path_dicts = []
    name_to_path = {}
    name_to_url = {}
    name_to_form = {}
    name_to_id = {}
    count = 1
    blacklisted_movies = []
    for rated_item in rated_items:
        if rated_item.movie in movies:
            blacklisted_movies.append(rated_item.movie)
    for movie in movies:
        if movie not in blacklisted_movies:
            rating_form = RatingForm(request.POST or None)
            name_to_form[movie.name] = rating_form
            name_to_path[movie.name] = movie.image
            name_to_url[movie.name] = movie.url
            name_to_id[movie.name] = movie.movielens_id
            if count % 4 == 0:
                name_to_path_dicts.append(name_to_path)
                name_to_path = {}
            count += 1
    name_to_path_dicts.append(name_to_path)
    if len(rated_items) < 10:
        heading = "Please rate atleast %d more item(s)" % (10 -
                                                           len(rated_items))
        button_status = 'disabled'
    else:
        heading = "You may proceed"
        button_status = ''
    context = {
        'heading': heading,
        'name_to_path_dicts': name_to_path_dicts,
        'name_to_url': name_to_url,
        'name_to_form': name_to_form,
        'name_to_id': name_to_id,
        'button_status': button_status
    }
    return render(request, 'rate.html', context)
Example #19
0
def demo_rate(request, demoid):
    context = RequestContext(request)
    context_dict = {}
    t = get_team(request.user)
    add_isteam_to_context_dict(context_dict, t)

    rater = get_rater(request.user)

    if rater:
        if request.method == 'POST':
            rating_form = RatingForm(data=request.POST)
            if rating_form.is_valid():
                demo = Demo.objects.get(id=demoid)

                # check if the rater has already rated this app, if so, remove this entry and replace with new rating
                rating_check = Rating.objects.filter(rater=rater,
                                                     demo=demo).count()
                if rating_check == 1:
                    past_rating = Rating.objects.get(rater=rater, demo=demo)
                    demo.rating_count = demo.rating_count - 1
                    demo.rating_sum = demo.rating_sum - past_rating.score
                    past_rating.delete()
                    demo.save()

                rating = rating_form.save(commit=False)
                rating.rater = rater
                rating.demo = demo
                rating.save()
                demo.rating_count = demo.rating_count + 1
                demo.rating_sum = demo.rating_sum + rating.score
                demo.save()

                return HttpResponseRedirect('/showcase/demo/show/' +
                                            str(demoid) + '/')
            else:
                print rating_form.errors
        else:
            rating_form = RatingForm()

            context_dict['rating_form'] = rating_form
            return render_to_response('showcase/demo.html', context_dict,
                                      context)

    return HttpResponseRedirect('/showcase/demo/show/' + str(demoid) + '/')
Example #20
0
def practice_flashcards(request,
                        mode='',
                        template_name='practice_flashcards.html'):
    """
    Practice a flashcard.
    """
    # Get the latest element you should practice
    practices = FlashCard.by_practice.filter(user=request.user)
    if len(practices) == 0:
        return render_to_response(template_name,
                                  {'errors': ['No items to practice']},
                                  context_instance=RequestContext(request))

    practice = practices[0]
    form = RatingForm(initial={'id': practice.id})

    # Multiple choice practice
    if mode == "multiple":
        # Return a list with three random flashcard items
        solutions = FlashCard.objects.all().order_by('?')[:2]

        return_dict = {
            'practice': practice,
            'form': form,
            'solutions': solutions
        }
    # default to "single"
    else:
        return_dict = {
            'practice': practice,
            'form': form,
        }

    return render_to_response(template_name,
                              return_dict,
                              context_instance=RequestContext(request))
Example #21
0
def demo_show(request, demoid):
    context = RequestContext(request)
    #TODO(leifos): add in error handlding and checking, handle gracefully
    demo = Demo.objects.get(id=demoid)
    team = demo.team
    ratings = Rating.objects.filter(demo=demo).order_by('-score')
    rater = get_rater(request.user)
    can_rate = False
    if rater:
        can_rate = True
    context_dict = {
        'team': team,
        'demo': demo,
        'ratings': ratings,
        'can_rate': can_rate
    }
    t = get_team(request.user)
    add_isteam_to_context_dict(context_dict, t)

    if can_rate:
        rate_form = RatingForm()
        context_dict['rate_form'] = rate_form

    return render_to_response('showcase/demo.html', context_dict, context)
Example #22
0
def api_add_rating(request, course_id):
    if request.method == 'POST':
        form = RatingForm(request.POST)
        results = []

        if form.is_valid():
            rating = form.save(commit=False)
            rating.user = UserProfile.objects.get(user=int(request.user.id))
            rating.date = datetime.datetime.now()
            try:
                c = Course.objects.get(id=int(course_id))
                rating.course = c
                rating.save()

                #update the course averages
                c.number_of_ratings += 1
                c.average_difficulty = ((c.average_difficulty if c.average_difficulty else 0) * (
                    c.number_of_ratings - 1) + Decimal(form.cleaned_data['difficulty_rating'])) \
                                       / Decimal(c.number_of_ratings)

                c.average_teaching = ((c.average_teaching if c.average_teaching else 0) * (
                    c.number_of_ratings - 1) + Decimal(form.cleaned_data['teaching_rating'])) \
                                     / Decimal(c.number_of_ratings)

                c.average_materials = (
                    (c.average_materials if c.average_materials else 0) *
                    (c.number_of_ratings - 1) +
                    Decimal(form.cleaned_data['materials_rating'])) / Decimal(
                        c.number_of_ratings)

                c.average_overall = ((c.average_overall if c.average_overall else 0) * (
                    c.number_of_ratings - 1) + Decimal(form.cleaned_data['overall_rating'])) \
                                    / Decimal(c.number_of_ratings)

                c.average_satisfaction = ((c.average_satisfaction if c.average_satisfaction else 0) * (
                    c.number_of_ratings - 1) + Decimal(form.cleaned_data['satisfaction_rating'])) \
                                         / Decimal(c.number_of_ratings)

                c.save()

                #response contains averages for the course, and the username of the submitter
                msg = {
                    "data": {
                        "overall": float(c.average_overall),
                        "satisfaction": float(c.average_satisfaction),
                        "difficulty": float(c.average_difficulty),
                        "teaching": float(c.average_teaching),
                        "materials": float(c.average_materials),
                        "ratings": c.number_of_ratings,
                        "username": request.user.username
                    }
                }
                results.append(msg)
            except Exception as e:
                return HttpResponseRedirect('/')
        else:
            print form.errors
            errors = {"errors": form.errors}
            results.append(errors)
        return HttpResponse(json.dumps(results),
                            content_type="application/json")

    else:
        return course(request, course_id)
Example #23
0
def rating(demand_id, recipient):
    """
    The '/bid/<demand_id>/rating/<recipient>' route is where the user can rate another user 
    for a demand they were involved in.
    """
    if 'username' not in session:
        return redirect(url_for('login'))

    demand_info = Demand.get_info(demand_id)

    # make sure the user is authorized to rate the recipient
    if session['role'] == 'developer':
        # developer rates the client, so client is recipient
        if session['username'] != demand_info['chosen_developer_username']:
            return render_template('access_denied.html')
    elif session['role'] == 'client':
        # client rates the developer, so developer is recipient
        if session['username'] != demand_info['client_username']:
            return render_template('access_denied.html')

    if Rating.check_if_valid_rating_form(int(demand_id), recipient,
                                         session['username']):
        form = RatingForm()

        if request.method == "GET":
            return render_template("rating.html",
                                   form=form,
                                   recipient=recipient,
                                   demand_id=demand_id)
        elif request.method == "POST":
            # low rating
            if form.rating.data <= 2:
                session['rating' + demand_id] = form.rating.data
                return redirect(
                    url_for('ratingMessage',
                            demand_id=demand_id,
                            recipient=recipient))
            elif form.rating.data == None:
                return render_template('rating.html',
                                       form=form,
                                       recipient=recipient,
                                       demand_id=demand_id)
            else:
                # add to form data
                Rating(demand_id, recipient, session['username'],
                       form.rating.data)

                # if the client gave a good rating to a developer (<= 3)
                # the remaining half of the bid amount gets transferred over to the developer
                if session['role'] == 'client':
                    bid_amount = Demand.get_info(
                        demand_id)['chosen_bid_amount']
                    Transaction(recipient, session['username'],
                                round(bid_amount / 2, 2))

                    # update developer's earnings
                    Developer.add_earnings(recipient, bid_amount)

                return render_template('ratingFinished.html',
                                       recipient=recipient)
    return render_template('access_denied.html')