def add_review(request, profID): if request.method == 'POST': form = ReviewForm(request.POST) if form.is_valid(): review = Review() review.professor = Professor.objects.get(id=profID) review.poster = request.user review.course = form.cleaned_data['course'] review.year_taken = form.cleaned_data['year_taken'] review.review = form.cleaned_data['review'] if Review.objects.filter(poster=request.user).filter(professor=review.professor).count > 0: params = { 'message': 'You cannot review the same professor multiple times', } return render(request, 'message.html', params) review.save() return HttpResponseRedirect('/accounts/profs/profID/' + profID + '/') else: form = ReviewForm() prof = Professor.objects.get(id=profID) params = { 'form': form, 'formTitle': 'Add a review for ' + str(prof.firstName) + ' ' + str(prof.lastName), } return render(request, 'profSearch.html', params)
def show_book(request, id_book): authenticated = False if request.user.is_authenticated(): authenticated = True book = Book.objects.get(id_book=id_book) if request.method == 'POST': review_form = ReviewForm(request.POST) if review_form.is_valid(): new_review = review_form.save(commit=False) new_review.book = book new_review.user = request.user new_review.save() # TODO: Get reviews by ISBN not by book reviews = Review.objects.filter(book=book) review_form = ReviewForm() if len(reviews): rating = round(sum([float(review.rating) for review in reviews]) / len(reviews), 2) else: rating = "No reviews yet" return render_to_response("book.html", context_instance=RequestContext(request, {'authenticated': authenticated, 'book': book, 'reviews': reviews, 'review_form': review_form, 'rating': rating}))
def add_review(request, bbl=None): lot = get_object_or_404(Lot, bbl=bbl) if request.method == 'POST': form = ReviewForm(request.POST) if form.is_valid(): form.save() return redirect('lots.views.details', bbl=bbl) else: initial_data = { 'reviewer': request.user, 'lot': lot, 'in_use': not lot.is_vacant, 'actual_use': lot.actual_use, } reviews = Review.objects.filter(lot=lot).order_by('-added') fields = ('in_use', 'actual_use', 'accessible', 'needs_further_review', 'nearby_lots', 'hpd_plans', 'hpd_plans_details') if reviews: last_review = reviews[0] for field in fields: initial_data[field] = last_review.__dict__[field] form = ReviewForm(initial=initial_data) return render_to_response('lots/add_review.html', { 'form': form, 'lot': lot, }, context_instance=RequestContext(request))
def single_product(request, slug): product = get_object_or_404(Product, slug=slug) prod = Product.objects.get(slug=slug) reviews = Review.objects.get(product=prod.id) reviewmatrix = {} user = request.user i = 0 try: for rev in reviews: reviewmatrix[str(i)] = [[review.review_text]] u = User.objects.get(username=rev.user) i = i + 1 except: u = User.objects.get(username=reviews.user) reviewmatrix[str(i)] = [[reviews.review_text]] if request.method=="POST": form = ReviewForm(request.POST) if form.is_valid(): user2 = get_object_or_404(User, pk=user.id) response = form.save(user=user2.id, product=prod.id) msg = 'Obrigado por avaliar ' + prod.name else: msg = 'Houve algum erro no servidor :(' return render(request, 'product_detail.html', {'prod':prod, 'reviews':reviews, 'user':u.first_name, 'msg':msg}) else: form = ReviewForm() args = {} args.update(csrf(request)) return render(request, 'product_detail.html', {'prod':prod, 'reviews':reviews, 'user':u.first_name, 'form':form})
def review(): form = ReviewForm() conversation_id = request.form.get('conversation_id') if request.method == 'POST' and form.validate_on_submit(): rating = request.form.get('rate') rq = Request.query. \ filter(Request.id == form.request_id.data).first() # reviewed_user_id = rq.user_id if rq.user_id == current_user.id \ # else rq.from_user_id reviewed_user_id = rq.from_user_id new_review = Review( user_id=current_user.id, reviewed_user_id=reviewed_user_id, request_id=rq.id, comment=form.comment.data, rating=rating ) db.session.add(new_review) db.session.commit() flash(u"Yorumunuz eklendi :)") return redirect('/show_stuff/%s' % rq.stuff_id) flash(u"Mesaj alanını boş bıraktınız.") return redirect('/conversation/%s' % conversation_id)
def review(request): saved = False review = '' if request.method == 'POST': form = ReviewForm(request.POST) if form.is_valid(): user_sender = User.objects.get(pk=request.POST['id_sender']) user_receiver = User.objects.get(pk=request.POST['id_receiver']) content = request.POST['content'] sent = True re = Review() re.id_sender = user_sender re.id_receiver = user_receiver re.content = content re.save() mail_data = {} mail_data['subject'] = 'You have a new review.' mail_data['message'] = ''' %s %s, <br> %s %s wrote a review about you. Here are the details<br> <h3>Details: </h3><br> %s ''' % (user_receiver.first_name, user_receiver.last_name, user_sender.first_name, user_sender.last_name, content) mail_data['from'] = '*****@*****.**' mail_data['sender'] = user_sender.email mail_data['receiver'] = user_receiver.email sent = utils.send_mail(mail_data) saved = True return HttpResponseRedirect('/trainer/%d' % (user_receiver.id)) else: return HttpResponseRedirect('/')
def review(request): # if this is a POST request we need to process the form data if request.method == 'POST': # create a form instance and populate it with data from the request: form = ReviewForm(request.POST) # check whether it's valid: if form.is_valid(): campus_audience = form.cleaned_data['campus_audience'] campus_need = form.cleaned_data['campus_need'] sponsor_name = form.cleaned_data['sponsor_name'] sponsor_netid = form.cleaned_data['sponsor_netid'] sponsor_email = form.cleaned_data['sponsor_email'] dev_name = form.cleaned_data['dev_name'] dev_email = form.cleaned_data['dev_email'] support_name = form.cleaned_data['support_name'] support_email = form.cleaned_data['support_email'] support_contact = form.cleaned_data['support_contact'] ats_review = form.cleaned_data['ats_review'] ux_review = form.cleaned_data['ux_review'] brand_review = form.cleaned_data['brand_review'] app_documentation = form.cleaned_data['app_documentation'] app_code = form.cleaned_data['app_code'] anything_else = form.cleaned_data['anything_else'] email_context = Context({ 'campus_audience': campus_audience, 'campus_need': campus_need, 'sponsor_name': sponsor_name, 'sponsor_netid': sponsor_netid, 'sponsor_email': sponsor_email, 'dev_name': dev_name, 'dev_email': dev_email, 'support_name': support_name, 'support_email': support_email, 'support_contact': support_contact, 'ats_review': ats_review, 'ux_review': ux_review, 'brand_review': brand_review, 'app_documentation': app_documentation, 'app_code': app_code, 'anything_else': anything_else }) try: send_mail( sponsor_name, get_template( 'mdotdevs/email_plain.html').render(email_context), sponsor_email, ['*****@*****.**'], html_message=get_template('mdotdevs/email_html.html') .render(email_context), ), except BadHeaderError: return HttpResponse('Invalid header found.') return render_to_response( 'mdotdevs/thanks.html', context_instance=RequestContext(request)) # if a GET (or any other method) we'll create a blank form else: form = ReviewForm() return render(request, 'mdotdevs/review.html', {'form': form})
def post_review(request, reviewId): context = RequestContext(request) user = request.user user_profile = UserProfile.objects.get(user=user.pk) review = Review.objects.get(pk=reviewId, user=user.pk) user_is_owner(user, review) project = Project.objects.get(pk=review.project.pk) rfp = RfpCampaign.objects.get(id=project.rfp.id) questions = rfp.get_review_questions() is_p = is_pi(user) is_rev = is_reviewer(user) review_item = Review.objects.get(user=user.pk, project=project.pk) review_model_dict = model_to_dict(review_item) redirect_url = get_redirect_url(request) + str("#yourreview") if request.method == "POST": form = ReviewForm(request.POST, request.FILES, questions=questions) if len(request.POST.get("next")) > 0: if form.is_valid(): form_data = form.cleaned_data updated_review = Review.objects.update_or_create(user=user.pk, project=project.pk, defaults=form_data) up_rev = updated_review[0] up_rev.save() return HttpResponseRedirect(request.POST.get("next")) else: if form.is_valid(): form_data = form.cleaned_data updated_review = Review.objects.update_or_create(user=user.pk, project=project.pk, defaults=form_data) up_rev = updated_review[0] up_rev.send_confirmation_email_to_reviewer() up_rev.status = "completed" up_rev.save() return HttpResponseRedirect(redirect_url) else: form = ReviewForm(initial=review_model_dict, questions=questions) return render_to_response( "rfp/post_review.html", { "is_pi": is_p, "is_rev": is_rev, "form": form, "project": project, "user": user, "up": user_profile, "review": review, }, context, )
def sign(request): form = ReviewForm(request.POST) if form.is_valid(): post = Post( author=form.clean_data["author"], review=form.clean_data["review"], rating=form.clean_data["rating"], appid=form.clean_data["appid"], appname=form.clean_data["appname"], ) # if users.GetCurrentUser(): # post.author = users.GetCurrentUser() post.put() return HttpResponseRedirect("/")
def reviewDetails(): reviews = Reviews.query.all() form = ReviewForm(request.form) if request.method == 'POST': if form.validate(): if form.id.data == '': r = Reviews(form.doctorID.data, form.description.data, form.username.data) db_session.add(r) db_session.commit() else: r = Reviews.query.get(int(form.id.data)) r.doctorID = form.doctorID.data r.description = form.description.data r.username = form.username.data db_session.commit() reviews = Reviews.query.all() return render_template('review.html', reviews=reviews)
def add_review(request, id): product = get_object_or_404(models.Product, pk=id) form = ReviewForm(request.POST) if form.is_valid(): review_text = form.cleaned_data['review_text'] review = form.save(commit=False) review.review_text = review_text review.user = request.user review.product = product review.date_published = timezone.now() review.save() return HttpResponseRedirect(reverse('details', args=(product.id,))) else: form = ReviewForm() return render(request, 'store/product-details.html', {'product': product, 'form': form}) return render(request, 'store/')
def review(request): import ep2Site.models plugin = ep2Site.plugins.reviewType.get_plugin(plugin) if request.method == 'POST': form = ReviewForm(request.POST) if form.is_valid(): review = form.save(commit=False) review.plugin = plugin.get_model() review.save() return HttpResponseRedirect(review.get_absolute_url()) else: return "[ERROR] from views: {0}".format(form.errors) else: form = ep2Site.forms.ReviewForm() return render_to_response('ep2Site/review.html', {'form': form}, context_instance=RequestContext(request))
def add_review(): ''' Function to display a page which displays a form to add a review for logged in user ''' if 'logged' not in session: # if a user trys to go to add review without been logged in flash('You need to log in to add a review', 'warning') return redirect(url_for('login')) # sending to log in form = ReviewForm() if form.validate_on_submit(): # if form submits successfully reviews = mongo.db.reviews # creating amazon link amazon_link = create_amazon_search(request.form['book_title']) icon = get_icon_class(request.form['category']) # creating icon font awesome class # add form content to db as a new record reviews.insert_one({ 'author': request.form['author'], 'book_title': request.form['book_title'], 'summary': request.form['summary'], 'review': request.form['review'], 'category': request.form['category'], 'amazon': amazon_link, 'icon': icon, 'upvote': 0, 'username': session['username'], }) flash('Review added ', 'success') # send to my reviews template on successful add return redirect(url_for('my_reviews')) return render_template('addreview.html', form=form, title='Add Review')
def book_details(request, book_id): book = Book.objects.get(pk=book_id) context = { 'book': book, } if request.user.is_authenticated(): if request.method == "POST": form = ReviewForm(request.POST) if form.is_valid(): new_review = Review.objects.create( user=request.user, book=context['book'], text=form.cleaned_data.get('text')) new_review.save() else: if Review.objects.filter(user=request.user, book=context['book']).count() == 0: form = ReviewForm() context['form'] = form context['reviews'] = book.review_set.all() return render(request, 'store/detail.html', context)
def product_review(request): id = request.GET.get('id') next = request.GET.get('next') product = get_object_or_404(Product.active, id=id) user = request.user if request.POST: form = ReviewForm(request.POST) if form.is_valid(): score = form.cleaned_data['score'] review = form.cleaned_data['review'] if not ProductReview.objects.filter(user=user, product=product).exists(): productreview = ProductReview.objects.create(user=user, product=product, score=score, review=review) else: print('gafgafg') print request.GET print request.POST return HttpResponseRedirect(next)
def review(affiliate_id=None): form = ReviewForm() a = models.Affiliate.query.get(affiliate_id) if form.validate_on_submit(): try: r = models.Review(affiliate_id=a.id, ipaddress=request.remote_addr, rating_overall=form.rating.data, rating_equipment=form.rating_equipment.data, rating_instructor=form.rating_instructor.data, comment=form.comment.data, review_date=datetime.datetime.utcnow()) db.session.add(r) db.session.commit() flash("Review for %s has been posted!" % a.name, 'success') return redirect('/') except: db.session.rollback() flash('You only can post one review!', 'error') else: if request.method == "POST": flash('Please make sure all fields are filled out correctly.', 'error') return render_template('review.html', affiliate_info = a, form = form)
def review(): if 'student_id' in session: form = ReviewForm() del form.delete id = session['student_id'] if form.validate_on_submit(): if form.post.data: review = Reviews(student_id=id, title=form.title.data, message=form.message.data) db.session.add(review) db.session.commit() flash('Thanks for your review!', 'success') return redirect(url_for('home')) else: return render_template('review.html', form=form, program=Student.query.get(id).program) flash('You must be logged first!', 'danger') return redirect(url_for('home'))
def add_review(subject): form = ReviewForm() subject_title = get_title(subject)[0] if request.method == 'GET': return render_template('add_review.html', form=form, subject=subject, subject_title=subject_title) elif request.method == 'POST': insert_review(None, subject, form.reviewer.data, form.review.data, form.rating.data) return redirect(url_for('review', subject=subject))
def show_book(request, id_book): authenticated = False if request.user.is_authenticated(): authenticated = True book = Book.objects.get(id_book=id_book) if request.method == 'POST': review_form = ReviewForm(request.POST) if review_form.is_valid(): new_review = review_form.save(commit=False) new_review.book = book new_review.user = request.user new_review.save() # TODO: Get reviews by ISBN not by book reviews = Review.objects.filter(book=book) review_form = ReviewForm() if len(reviews): rating = round( sum([float(review.rating) for review in reviews]) / len(reviews), 2) else: rating = "No reviews yet" return render_to_response("book.html", context_instance=RequestContext( request, { 'authenticated': authenticated, 'book': book, 'reviews': reviews, 'review_form': review_form, 'rating': rating }))
def add_review(request,movie_id): rm=Movie.objects.get(id=movie_id) if request.method == "POST": f=ReviewForm(request.POST) if f.is_valid(): r=f.save(commit=False) r.user=request.session['user'] r.post_date = timezone.now() r.movie =rm r.save() return HttpResponseRedirect('/movies/get/%s' % movie_id) else: f=ReviewForm() args={} args.update(csrf(request)) args['movie']=rm args['form']=f; if 'user' in request.session: args['result']=request.session['user'] return render_to_response('add_review.html',args)
def add_feedback(username): if "user_id" not in session: return redirect("/login") else: form = ReviewForm() if form.validate_on_submit(): title = form.title.data content = form.content.data review = Review(title=title, content=content, user_id=session["user_id"]) db.session.add(review) db.session.commit() return redirect(f"/feedback/{review.id}") else: return render_template("feedback-form.html", form=form)
def review(book_id): rating = request.form.get("rating") review = request.form.get("text") book = db.execute("SELECT * FROM books WHERE id = :book_id", { "book_id": book_id }).fetchone() if db.execute( "SELECT * FROM reviews WHERE user_id = :user_id AND book_id = :book_id", { "user_id": session['user_id'], "book_id": book_id }).rowcount != 0: flash("Only one review allowed") book = db.execute("SELECT * FROM books WHERE id = :book_id", { "book_id": book_id }).fetchone() form = ReviewForm() user_review = db.execute( "SELECT * FROM reviews WHERE user_id = :user_id AND book_id = :book_id", { "user_id": session['user_id'], "book_id": book.id }).fetchone() user_review = user_review.review goodreadsData = requests.get( "https://www.goodreads.com/book/review_counts.json", params={ "isbns": book.isbn_id, "key": "VzAR63bf45MBzRSC1o1A" }) if goodreadsData.status_code != 200: raise Exception("ERROR: API REQUEST UNSUCCESSFUL, {}".format( res.status_code)) return render_template("book.html", book=book, form=form, data=goodreadsData, user_review=user_review) else: db.execute( "INSERT INTO reviews (user_id, book_id, rating, review) VALUES (:user_id, :book_id, :rating, :review)", { "user_id": session['user_id'], "book_id": book_id, "rating": rating, "review": review }) db.commit() flash("Review Submitted!") return redirect(url_for("book", isbn_id=book.isbn_id))
def add(week_id): """Add a daily review task.""" f = ReviewForm() # print(f.data) if f.validate_on_submit(): review_dt = datetime.combine(f.date.data, time.min) rev = Review.query.filter_by(review_day=review_dt).first() if rev is None: rev = Review() rev.week_id = week_id rev.review_day = f.date.data db.session.add(rev) db.session.commit() rev.planning = f.planning.data if f.planning.data else rev.planning rev.dev = f.dev.data if f.dev.data else rev.dev rev.tickets = f.tickets.data if f.tickets.data else rev.tickets rev.cleanup = f.cleanup.data if f.cleanup.data else rev.cleanup rev.review = f.review.data if f.review.data else rev.review rev.goals = f.goals.data if f.goals.data else rev.goals db.session.commit() # else: # print('validation failed') return redirect(url_for('worksheet.worksheet', week_id=week_id))
def update_feedback(review_id): if "user_id" not in session: return redirect("/login") else: review = Review.query.get_or_404(review_id) if review.user_id == session["user_id"]: form = ReviewForm(obj=review) if form.validate_on_submit(): review.title = form.title.data review.content = form.content.data db.session.commit() return redirect(f"/feedback/{review.id}") else: return render_template("feedback-form.html", form=form) return redirect("/")
def create_review(request, template="create_project.html"): project_id = request.GET.get("project_id") print "create application review for project:{}".format(project_id) project = None if project_id is not None: project = get_object_or_404(Project, pk=project_id) if request.method == "POST": # Must pass request.FILES to ModelForm so it can handle file upload form = ReviewForm(request.POST, request.FILES, initial={"project": project}) new_review = form.save() print new_review if project_id is None: project_id = new_review.project.id event = {"time": datetime.now(), "project_id": int(project_id), "message": _("Create ApplicationReview")} create_log(event) return redirect("enterprise.reviews") else: form = ReviewForm(initial={"project": project}) context = {"form": form, "title": _("Create ApplicationReview")} return render(request, template, context)
def displayArticle(filename): if 'logged_in' not in session: flash("You Have To Login First To Access This Page..!!") return redirect(url_for('login')) details, article, status, comment = viewArticle(filename) if status == True: return render_template('view.html', form=ReviewForm(), form1=CommentForm(), details=details, article=article, comment=comment) flash(status) return redirect(url_for('home'))
def index(): form = ReviewForm() print(request.method) if request.method == 'POST': if form.validate_on_submit(): form_data_list = [form.username.data, form.product_name.data, form.product_review.data] print(f'User name {form.username.data}') print(f'Product Name {form.product_name.data}') print(f'Product Review {form.product_review.data}') with open('static/data/reviews.csv', 'a+', newline='') as write_obj: csv_writer = csv.writer(write_obj) csv_writer.writerow(form_data_list) form.username.data = '' form.product_name.data = '' form.product_review.data = '' print(f'submitted successfully') print('hi') # flash('Review Posted Successfully!', category='info') return redirect('/') with open('static/data/reviews.csv') as csv_file: data = csv.reader(csv_file, delimiter=',') first_line = True reviews = [] for row in data: if first_line: first_line = False else: reviews.append(dict(username=row[0], product_name=row[1], product_review=row[2])) return render_template('index.html', form=form, reviews=reviews)
def booksearch(isbn): book = db.execute("SELECT * FROM books WHERE isbn = :isbn",{"isbn":isbn}).first() review = db.execute("SELECT * FROM reviews WHERE booksisbn = :isbn",{"isbn":isbn}).fetchall() form = ReviewForm() if book == None : flash("Book Does Not Exist") return redirect(url_for('search')) if request.method == "POST": # Check if user is logged in, else return error if session.get('user_id') != None : user = db.execute("SELECT * FROM member \ WHERE username = :username" ,{"username": session['user_id'] }).first() check = db.execute('SELECT * FROM reviews WHERE \ memberusername = :username AND \ booksisbn = :isbn',{'username': user.username, 'isbn':isbn}).first() if check != None: flash('You have already submmited a review') return redirect("/search/" + isbn) db.execute("INSERT INTO reviews (review, memberid, booksisbn, memberusername, ratings)\ VALUES (:review, :memberid, :booksisbn, :memberusername, :ratings)", {"review": form.review.data, "memberid": user.id, "booksisbn": isbn, "memberusername": user.username, "ratings":form.ratings.data }) db.commit() flash("Review Successfully Posted") return redirect("/search/" + isbn) else: flash("Please Login To Leave a Review") return redirect("/search/" + isbn) # get session username, find the username object in db # add review to database with ISBN & User ID # Db commit key = os.getenv("GOODREADS_KEY") query = requests.get("https://www.goodreads.com/book/review_counts.json", params={"key": key, "isbns": isbn}) response = query.json() response = response['books'][0] return render_template('results.html', book=book, response=response, form=form, review=review)
def make_review(): form = ReviewForm() form.name.choices = [] for row in fetch_available_items('beer_choices', 'products'): stock = str(row[0]) form.name.choices += [(stock, stock)] if request.method == "POST" and form.validate(): username = form.username.data name = form.name.data score = form.score.data post = form.post.data c, conn = connection() c.execute("SELECT id FROM users where username LIKE %s", [thwart(username)]) current_id = c.fetchone() c.execute("SELECT id FROM beer where name LIKE %s", [thwart(name)]) current_beer = c.fetchone() c.execute("SELECT CURDATE()") current_date = c.fetchone() # print current_id # print current_beer c.execute( """INSERT INTO Review (user_id, beer_id, userName, score, body, date) VALUES (%s, %s, %s, %s, %s, %s)""", (current_id, current_beer, thwart(username), thwart( str(score)), thwart(post), current_date)) conn.commit() flash("Thanks for submitting your review!") c.close() conn.close() gc.collect() return redirect(url_for("homepage")) return render_template("make_review.html", form=form)
def create_movie_review(movie_id): """Show a form for a user to create a review for a movie, and add the review to reviews table.""" if not g.user: flash("You must be signed in to leave a review") return redirect("/") movie = get_results(requests.get(f"{api_base}movie/{movie_id}{api_key}")) if is_movie(movie) == False: flash("We couldn't find that movie.") return redirect("/") in_movies(movie) form = ReviewForm() if form.validate_on_submit(): review = Review(title=form.title.data, body=form.body.data, rating=form.rating.data, username=g.user.username, movie_id=movie_id) db.session.add(review) db.session.commit() return redirect(f"/movie/{movie_id}") return render_template("movies/review.html", movie=movie, form=form)
def adicionar(request): form = ReviewForm() if request.method == 'POST': form = ReviewForm(request.POST) if form.is_valid(): review = Review(user = request.user) form = ReviewForm(request.POST, instance=review) form.save() return redirect('/review/') return render(request, 'review/adicionar.html', locals())
def review(movie_id): form = ReviewForm() if session.get('user'): # Get current user for review info user = session["user"].capitalize() # Connection to the movie database movie = tmdb.Movies(movie_id) response = movie.info() # Create veriables for title, overview and post path. movie_title = movie.title movie_id = movie.id movie_overview = movie.overview poster_path = movie.poster_path # Information about movies that will be reviews = list( mongo.db.reviews.find({}, { 'movie_id': 1, 'movie_title': 1, 'username': 1, 'review_text': 1, '_id': 1 })) # Review information to send to the database review_info = { "movie_id": movie_id, "movie_title": movie.title, "username": user, "review_text": request.form.get("review") } if form.review.data and request.method == 'POST': mongo.db.reviews.insert_one(review_info) flash("Successfully posted your review", "success") return redirect(url_for("movies.review", movie_id=movie_id)) return render_template('review.html', form=form, reviews=reviews, movie_id=movie_id, movie_title=movie_title, movie_overview=movie_overview, poster_path=poster_path, user=user) else: flash("You need to login in order to view reviews", "error") return redirect(url_for("auth.login"))
def project_detail(request,projectId): context = RequestContext(request) user = request.user project = Project.objects.get(id=projectId) list_of_review = Review.objects.filter(project = project, status = 'completed', dropped = False) review = find_user_review_for_project(user,project) questions = project.rfp.get_review_questions() if review: review_data = ReviewForm(data=model_to_dict(review),questions=questions) else: review_data= {} project_data = ProjectForm(data=model_to_dict(project), questions = project.rfp.get_project_questions()) prop_rev_list = ProposedReviewer.objects.filter(project = project, type='USER_PROPOSED') refused_rev_list = ProposedReviewer.objects.filter(project = project, type='USER_EXCLUDED') budget_line_list = BudgetLine.objects.filter(project = project) hr_budget_line_list = BudgetLine.objects.filter(project = project,category = 'HR') oc_budget_line_list = BudgetLine.objects.filter(project = project,category = 'OC') eq_budget_line_list = BudgetLine.objects.filter(project = project,category = 'EQ') is_p = is_pi(user) is_rev = is_reviewer(user) oc_total = budget_line_sum(oc_budget_line_list) hr_total = budget_line_sum(hr_budget_line_list) eq_total = budget_line_sum(eq_budget_line_list) total = oc_total + hr_total + eq_total current_url = reverse('project_budget', args = [project.pk]) project.list_of_reviewers_id() user_is_owner(user,project) store_redirect_url(request) context_dict={'project' : project,'user' : user, 'project_data' : project_data,'is_pi': is_p, 'bl' : budget_line_list, 'is_rev' : is_rev,'review_data' : review_data, 'prop_rev_list' : prop_rev_list,'excluded_rev_list' : refused_rev_list, 'current_url':current_url, 'review' : review, 'hr_budget_lines_list' : hr_budget_line_list, 'oc_budget_lines_list' : oc_budget_line_list, 'eq_budget_lines_list' : eq_budget_line_list, 'oc_total' : oc_total, 'hr_total' : hr_total, 'eq_total' : eq_total, 'total' : total, 'list_of_review' : list_of_review} return render_to_response('rfp/project_details.html',context_dict,context)
def display_movies(): """ Get all movies from the database in order to display them in the template. """ form = ReviewForm() # Workaround to pop movie results from session on page reload if session.get('results') is not None: session.pop('results', None) display_movies = mongo.db.movies.find({}, { 'movie_id': 1, 'movie_title': 1, 'movie_overview': 1, 'poster_path': 1, '_id': 0 }) return render_template('movies.html', display_movies=list(display_movies), form=form)
def create_review(request, series_id): if request.POST: form = ReviewForm(request.POST, series_id) if form.is_valid(): form.save() return HttpResponseRedirect('/genre/all/') #stuck this here, trying to get past it else: form = ReviewForm() args = {} args.update(csrf(request)) args['form'] = form args['series_id'] = series_id return render_to_response('create_review.html', args)
def project_review(request,projectId): context = RequestContext(request) user = request.user project=Project.objects.get(id=projectId) review = Review.objects.get(project=projectId,user=user.pk) questions = project.rfp.get_review_questions() review_data = ReviewForm(data=model_to_dict(review),questions=questions) is_p = is_pi(user) is_rev = is_reviewer(user) user_is_owner(user,review) store_redirect_url(request) context_dict={'project' : project,'user' : user,'review_data' : review_data, 'is_pi': is_p,'is_rev' : is_rev,'review':review} return render_to_response('rfp/project_review.html',context_dict,context)
def book(isbn): form = ReviewForm(request.form) # Because an isbn check has already been performed in profile, no check is required query = sql_db.execute("Select * From books WHERE isbn = :isbn", {"isbn":isbn}).fetchall() # Grabs GoodReads review information using their API, gotBookInfo() is in services.py gr_data = getBookInfo(isbn, query) userReview = sql_db.execute("SELECT * FROM reviews WHERE username = :username AND isbn = :isbn", {"username": session['username'], "isbn":isbn}).fetchall() allReviews = sql_db.execute("SELECT * FROM reviews WHERE isbn = :isbn", {"isbn":isbn}).fetchall() username = session['username'] title = query[0][2] author = query[0][3] published = query[0][4] userscore = 0 user_review = '' if len(userReview) > 0: userscore = userReview[0][1] user_review = userReview[0][2] else: if request.method == 'POST': userscore = form.score.data user_review = form.review.data sql_db.execute("INSERT INTO reviews (score, review, username, isbn) VALUES(:score, :review, :username, :isbn)", {"score": str(userscore), "review": user_review, "username": username, "isbn": isbn}) sql_db.commit() # used for testing purposes only # print(isbn, username, userscore, user_review); return render_template('book.html', username = username, isbn = isbn, title = title, author = author, published = published, userscore = userscore, user_review = user_review, gr_data = gr_data, allReviews=allReviews, userReview=userReview)
def create(movie_id): """ Let the users create reviews from the search results """ form = ReviewForm() # Connection to the movie database movie = tmdb.Movies(movie_id) response = movie.info() # Create veriables for title, overview and post path. movie_title = movie.title movie_id = movie.id movie_overview = movie.overview poster_path = movie.poster_path # Check if how many times the movie id exists in the database existing_movie = mongo.db.movies.find({ "movie_id": movie_id }, { '_id': 0 }).count() # Information about the movie to send to the database movie_info = { "movie_id": movie_id, "movie_title": movie_title, "movie_overview": movie_overview, "poster_path": poster_path } if form.create.data and request.method == 'POST': # If the movie id exists less than 1 one time if existing_movie >= 1: flash("Redirected to existing review!", "info") # If the movie id does not exist in the database else: flash("Created Movie!", "success") # Insert movie information mongo.db.movies.insert_one(movie_info) return render_template('review.html', form=form, movie_id=movie_id, movie_title=movie_title, movie_overview=movie_overview, poster_path=poster_path)
def delete_review(barberid, id): if request.args.get('neighborhood') == None: neighborhood_code = "ga" else: neighborhood_code = request.args.get('neighborhood') neighborhood = neighborhoods_by_key.get( neighborhood_code) # tab this over if necessary review_param = int(id) barber_param = int(barberid) review = models.Review.get_or_none(review_param) if str(review.user_id) == str(current_user.id): review.delete_instance() form = ReviewForm() barber = models.Barber.get(models.Barber.id == barber_param) reviews = barber.reviews flash('you deleted your review') return redirect(url_for('barbers', id=barber_param)) else: flash('you cannot delete a review that is not yours') return redirect( url_for('barbers', id=barber_param, neighborhood=neighborhood))
def post_review(request,reviewId): context = RequestContext(request) user = request.user user_profile = UserProfile.objects.get(user = user.pk) review = Review.objects.get(pk = reviewId, user=user.pk) user_is_owner(user,review) project = Project.objects.get(pk = review.project.pk) rfp = RfpCampaign.objects.get(id = project.rfp.id) questions = rfp.get_review_questions() is_p = is_pi(user) is_rev = is_reviewer(user) review_item = Review.objects.get(user = user.pk, project = project.pk) review_model_dict = model_to_dict(review_item) redirect_url = get_redirect_url(request) + str('#yourreview') if request.method == 'POST': form = ReviewForm(request.POST,request.FILES,questions=questions) if len(request.POST.get('next')) > 0: if form.is_valid(): form_data = form.cleaned_data updated_review = Review.objects.update_or_create(user = user.pk, project = project.pk, defaults=form_data) up_rev = updated_review[0] up_rev.save() return HttpResponseRedirect(request.POST.get('next')) else: if form.is_valid(): form_data = form.cleaned_data updated_review = Review.objects.update_or_create(user = user.pk, project = project.pk, defaults=form_data) up_rev = updated_review[0] up_rev.send_confirmation_email_to_reviewer() up_rev.status = 'completed' up_rev.save() return HttpResponseRedirect(redirect_url) else: form = ReviewForm(initial= review_model_dict,questions = questions) return render_to_response('rfp/post_review.html',{'is_pi' : is_p, 'is_rev': is_rev, 'form' : form, 'project' : project, 'user' : user, 'up' : user_profile,'review' : review}, context)
def stream(username=None): form = ReviewForm() form2 = EditReviewForm() form4 = EditProfileForm() formData = form2.idNumber.data user = models.User.select().where( models.User.username == current_user.username).get() stream = user.stream.limit(100) stream2 = user.swipe.limit(100) if form2.validate_on_submit(): if form2.idNumber.data == None: print("SAAAAAAAAAD") else: intFormData = int(formData) print(intFormData) if Review.id == intFormData and 0 < form.rating.data < 6: plant = Review.get(Review.id == (intFormData)) plant.text = form2.text.data plant.rating = form2.rating.data plant.plant = form2.plant.data plant.save() else: flash( "Could not edit review, please ensure you have filled out all the fields correctly" ) return render_template('stream.html', stream=stream, stream2=stream2, form=form, form2=form2, form4=form4, username=username, user=user)
def book(isbn): form = ReviewForm(csrf_enabled=False) if request.method == "POST": review = { "rating": form.rating.data, "review": form.review.data, "user_id": session["id"], "book_id": form.book_id.data } add = add_review(db, review) if add == True: flash("your review has been added...") return redirect(url_for("book", isbn=isbn)) elif add == False: flash("Database Error..!, please Email: [email protected]") return redirect(url_for("book", isbn=isbn)) else: flash(add) return redirect(url_for("book", isbn=isbn)) if request.method == "GET": book = find_book(db, isbn) if book: reviews = get_reviews(db, book.id) try: url = f'https://www.goodreads.com/book/review_counts.json?key=fWW2DdoQzw82qH5DEIe4CQ&isbns={book.isbn}' h = httplib2.Http() result = h.request(url, 'GET')[1] result = json.loads(result)['books'][0] print(result) goodreads = result except: goodreads = None return render_template("book.html", book=book, reviews=reviews, goodreads=goodreads, form=form)
def add_review(request, id): product = get_object_or_404(models.Product, pk=id) form = ReviewForm(request.POST) if form.is_valid(): review_text = form.cleaned_data['review_text'] review = form.save(commit=False) review.review_text = review_text review.user = request.user review.product = product review.date_published = timezone.now() review.save() return HttpResponseRedirect(reverse('details', args=(product.id, ))) else: form = ReviewForm() return render(request, 'store/product-details.html', { 'product': product, 'form': form }) return render(request, 'store/')
def add_review(request, movie_id): rm = Movie.objects.get(id=movie_id) if request.method == "POST": f = ReviewForm(request.POST) if f.is_valid(): r = f.save(commit=False) r.user = request.session['user'] r.post_date = timezone.now() r.movie = rm r.save() return HttpResponseRedirect('/movies/get/%s' % movie_id) else: f = ReviewForm() args = {} args.update(csrf(request)) args['movie'] = rm args['form'] = f if 'user' in request.session: args['result'] = request.session['user'] return render_to_response('add_review.html', args)
def sub(): form = ReviewForm() if form.validate_on_submit(): flash('Review Submitted Successfully') return render_template('home.html', form=form)
def show_conversation(conversation_id): conversation = Conversation.query.\ filter(Conversation.id == conversation_id).first() if current_user not in conversation.users: redirect('/my_messages') form = ConversationForm() if request.method == 'POST' and form.validate_on_submit(): if current_user.id == conversation.request.user.id: to_user = conversation.request.from_user else: to_user = conversation.request.user print to_user.id new_message = Message( from_user=current_user, to_user=to_user, conversation=conversation, txt=form.message.data ) db.session.add(new_message) db.session.commit() msg_body = render_template('email/conversation.txt', user=to_user, from_user=current_user.name, stuff_title=conversation.title, conversation=new_message) html_msg = render_template('email/conversation.html', user=to_user, from_user=current_user.name, stuff_title=conversation.title, conversation=new_message) # msg_body = u'%s sana mesaj gönderdi. <br><br> esyakutuphanesi.com'\ # % current_user.name # html_msg = u'%s sana mesaj gönderdi. <br><br> Mesajı okumak için' \ # u' <a href="http://esyakutuphanesi.com/conversation/{{conversation_id}}">tıkla!</a>' \ # % current_user.name msg_subject = u"Mesajın var" msg = MailMessage( body=msg_body, html=html_msg, subject=msg_subject, sender=(u"Eşya Kütüphanesi", "*****@*****.**"), recipients=[to_user.email] ) mail.send(msg) Message.query.filter( Message.conversation_id == conversation_id, Message.status == 0, Message.to_user == current_user ).update({Message.status: 1}) db.session.commit() form.message.data = None review_form = ReviewForm() if request.args.get('status'): status = int(request.args.get('status')) else: status = 0 if status > 0 and \ (conversation.request.stuff.owner == current_user or conversation.request.from_user_id == current_user.id): if conversation.request.stuff.status == 1: if status == 1 and conversation.request.status == 0: flash(u'Eşyayı vermeyi kabul ettiniz.') conversation.request.stuff.status = 0 conversation.request.status = 1 conversation.request.given_at = datetime.utcnow() db.session.commit() elif status == 2 and conversation.request.status == 1: flash(u'Eşyayı geri aldınız.') conversation.request.stuff.status = 1 conversation.request.status = 2 conversation.request.returned_at = datetime.utcnow() db.session.commit() else: flash(u'Eşya zaten başkasına verilmiş.') wanted_stuff = StuffPhoto.query.filter(StuffPhoto.stuff_id == conversation.request.stuff_id).first() review_form.request_id.data = conversation.request_id return render_template( "conversation.html", user=current_user, wanted_stuff=wanted_stuff, form=form, action='Edit', conversation=conversation, review_form=review_form )
def movie(imdb_id): #Uses Review Form object from forms.py form = ReviewForm() #Update DB when new form is submitted if form.validate_on_submit(): db.execute( "INSERT INTO reviews (userid, imdbid, rating, content) VALUES (:un, :ii, :ra, :co);", { "un": session['current_user'], "ii": imdb_id, "ra": form.select.data, "co": form.content.data }) db.commit() return (redirect(url_for('movie', imdb_id=imdb_id))) # Ensure that movie exists movie = db.execute("SELECT * FROM movies WHERE imdbid = :id", { 'id': imdb_id }).fetchone() if movie == None: abort(404) else: #Retrieve additional data from omdb imdb_id = movie[3] attrlist = [ "Title", "Year", "Rated", "Released", "Runtime", "Genre", "Director", "Writer", "Actors", "Plot", "Language", "Country", "Awards", "Poster", "Metascore", "imdbRating", "imdbVotes", "imdbID", "Type", "DVD", "BoxOffice", "Production", "Website", "Response" ] omdbResults = omdb.request(i=imdb_id) omdbData = omdbResults.json() temp = {} for attr in attrlist: temp[attr] = omdbData[attr] # Get all reviews revu = db.execute("SELECT * FROM reviews WHERE imdbid = :imdbid", { "imdbid": imdb_id }).fetchall() attrlist2 = ["Author", "MovieID", "Rating", "ReviewContent"] reviews = [] temp2 = {} #Check if user has submitted a review userRev = False for i in range(len(revu)): temp2 = {} for j in range(len(revu[i])): temp2[attrlist2[j]] = revu[i][j] reviews.append(temp2) if temp2['Author'] == session['current_user']: userRev = True #Sets reviews to blank list, not None if revu == None: reviews = [] #Get average score from Metascore & imdbRating try: avgR = (float(temp['Metascore']) + float(temp['imdbRating']) * 10) / 2 except: try: avgR = temp['imdbRating'] except: avgR = temp['Metascore'] return render_template("movie.html", movie=temp, reviews=reviews, avgR=avgR, form=form, userRev=userRev)