def add_msg():
Feedback.create(request.json)
message = Message('githubDoc反馈',
recipients=current_app.config.get('MAIL_RECIPIENTS'),
body=request.json.get('msg'))
mail.send(message)
return response()
def add_feedback(username):
"""
GET /users/<username>/feedback/add
Display a form to add feedback Make sure that only the
user who is logged in can see this form
POST /users/<username>/feedback/add
Add a new piece of feedback and redirect
to /users/<username> — Make sure that only
the user who is logged in can successfully add feedback
"""
curr_username = session.get('user')
if curr_username:
if curr_username == username:
form = FeedbackForm()
if form.validate_on_submit():
title = form.title.data
content = form.content.data
comment = Feedback(title=title,
content=content,
username=username)
comment.update_db()
return redirect(f'/users/{username}')
else:
return render_template('add_feedback_form.html', form=form)
else:
flash("Eyes on Your own Profile", "warning")
return redirect(f'/users/{curr_username}')
else:
flash("Please Log In", "danger")
return redirect('/')
def feedback():
if request.method == 'GET':
return render_template('feedback.html')
elif request.method == 'POST':
form = request.form
content = form['content']
new_feedback = Feedback(content=content, time=datetime.now())
new_feedback.save()
return redirect(url_for("index"))
def index():
objective = Objective.select().where(Objective.user_id == current_user.id)
compliments_received_msg = Compliment.select().where(
Compliment.recipient_id == current_user.id).limit(5)
compliments_given_msg = Compliment.select().where(
Compliment.sender_id == current_user.id).limit(5)
departments = User.select().where(
User.department == current_user.department)
all_users = User.select()
compliments_received = Compliment.select().where(
Compliment.recipient_id == current_user.id).count()
compliments_given = Compliment.select().where(
Compliment.sender_id == current_user.id).count()
user = User.get_or_none(User.id == current_user.id)
rep = Feedback.select().where(Feedback.requester_id == current_user.id)
feedback_exist = Feedback.select().where(
(Feedback.receiver_id == current_user.id)
& (Feedback.answered == False))
star = Medal.select().where(Medal.medal_caption == "Star").get()
gold = Medal.select().where(Medal.medal_caption == "Gold").get()
silver = Medal.select().where(Medal.medal_caption == "Silver").get()
bronze = Medal.select().where(Medal.medal_caption == "Bronze").get()
completed_objectives = Objective.select().where(
(Objective.user_id == user.id) & (Objective.done == True))
incomplete_objectives = Objective.select().where(
(Objective.user_id == user.id) & (Objective.done == False))
try:
progress = (
completed_objectives.count() /
(completed_objectives.count() + incomplete_objectives.count()))
except ZeroDivisionError:
progress = 0
progress_percentage = "{:.0%}".format(progress)
return render_template('dashboard/new.html',
objectives=objective,
compliments_received_msg=compliments_received_msg,
compliments_given_msg=compliments_given_msg,
departments=departments,
all_users=all_users,
user=user,
progress_percentage=progress_percentage,
progress=progress,
compliments_received=compliments_received,
compliments_given=compliments_given,
gold=gold,
silver=silver,
bronze=bronze,
star=star,
feedback_exist=feedback_exist,
rep=rep)
def reply(id):
reply_message = request.form.get('formReply')
Feedback.update(answered=True).where(Feedback.id == id).execute()
Replies(reply_message=reply_message, feedback_replied_id=id).save()
any_feedback_left = False
feedback_exist = Feedback.select().where(
(Feedback.receiver_id == current_user.id)
& (Feedback.answered == False))
if feedback_exist:
any_feedback_left = True
resp = {'success': True, 'any_feedback_left': any_feedback_left}
return jsonify(resp)
def install_feedback_data():
"""Create all the required feedback if not defined"""
from application import db
from models.feedback import Feedback
itemList = [
#{'scope': 'roles', 'name': 'member', 'raw_value': '[]'}
]
for item in itemList:
feedback = Feedback.query.filter_by(scope=item['scope'], name=item['name']).first()
if not feedback:
feedback = Feedback(**item)
feedback.save()
def handle_feedback_update(feedback_id):
"""
GET /feedback/<feedback-id>/update
Display a form to edit feedback — **Make sure that only the user who has written that feedback can see this form **
POST /feedback/<feedback-id>/update
Update a specific piece of feedback and redirect to /users/<username> — Make sure that only the user who has written that feedback can update it
"""
curr_username = session.get('user')
#someone is logged in
if curr_username:
#get the comment from the db
comment = Feedback.get(feedback_id)
#if the loggged in user is the same as the comment writer, then you can continue
if curr_username == comment.username:
#Most Common Path
form = FeedbackForm(obj=comment)
if form.validate_on_submit():
comment.update_from_serial(request.form)
return redirect(f'/users/{curr_username}')
else:
return render_template('edit_feedback_form.html', form=form)
#outlier path
else:
flash('Eyes on your own work!', 'warning')
return redirect(f'/users/{curr_username}')
#outlier path
else:
flash('Please Log in')
return redirect('/')
def setUp(self):
owner = Owner('Jack',
'White',
'*****@*****.**',
'487239847',
True,
id=5)
self.feedback = Feedback(1, 2, 3, 4, 'sugg', 'oth', owner, 6)
def feedback_result():
if "loggedin" in session:
if session['loggedin'] == True:
all_feedback = Feedback.objects()
return render_template('feedback-result.html', all_feedback=all_feedback)
else:
return redirect(url_for('login'))
else:
return redirect(url_for('login'))
def feedback():
mlab.connect()
feedback_list = Feedback.objects(post=True)
print(feedback_list)
return render_template('comment.html', feedback_list=feedback_list)
# if __name__=='__main__':
# app.run(debug=True)
def feedback_submit():
from models.feedback import Feedback
title = g._t("submit feedback")
if request.values.get("csrf_token", None):
feedback = Feedback()
feedback.account = g.account
feedback.subject = request.values.get("feedback_subject", "").strip()
feedback.message = request.values.get("feedback_message", "").strip()
feedback.created = int(time.time())
validationErrors = feedback.validate()
if not validationErrors:
status = 200
description = "OK"
feedback.save()
if request.is_ajax:
return Response(
json.dumps(
{
"html": render_template(
"_popup.html",
title=g._t("feedback submit success"),
message=g._t("feedback submit success message"),
),
"status": status,
"description": description,
"errors": validationErrors,
}
),
mimetype="application/json",
)
else:
flash(g._t("feedback submit success"))
return redirect(url_for("application_index"))
else:
status = 400
description = "Bad request"
else:
status = 200
description = "OK"
validationErrors = []
if request.is_ajax:
htmlContent = render_template("feedback/submit-popup.html", title=title, errors=validationErrors)
return Response(
json.dumps({"html": htmlContent, "status": status, "description": description, "errors": validationErrors}),
mimetype="application/json",
)
else:
htmlContent = render_template("feedback/submit.html", title=title, errors=validationErrors)
return htmlContent
def feedback_POST(id):
qos = int(request.form.get('qos'))
fs = int(request.form.get('fs'))
cf = int(request.form.get('cf'))
recommend = request.form.get('recommend')
suggestions = request.form.get('suggestions')
other_comment = request.form.get('other_comment')
owner = OwnerRep().select(id)
feedback = Feedback(qos, fs, cf, recommend, suggestions, other_comment,
owner)
FeedbackRep().save(feedback)
return redirect('/owners/' + id + '/feedbacks')
def get_feedbacks(self, owner_id):
feedbacks = []
sql = "SELECT * FROM feedbacks WHERE owner_id = %s"
values = [owner_id]
results = run_sql(sql, values)
for row in results:
owner = self.select(owner_id)
feedback = Feedback(row['qos'], row['fs'], row['cf'],
row['recommend'], row['suggestions'],
row['other_comment'], owner, row['id'])
feedbacks.append(feedback)
return feedbacks
def dict_lawyer(self):
data = {}
data['id'] = self.key.id()
data['case_id'] = self.key.id()
data['lawyer'] = None
if self.lawyer:
lawyer = self.lawyer.get()
data['lawyer_id'] = lawyer.key.id()
data['lawyer'] = lawyer.dict_nodate()
data['feedback'] = None
feedback = Feedback.query(Feedback.lawyer == self.lawyer).get()
if feedback:
data['feedback'] = feedback.solo_dict()
return data
def dict_client(self):
data = {}
data['id'] = self.key.id()
data['case_id'] = self.key.id()
data['client'] = None
if self.client:
client = self.client.get()
data['client_id'] = client.key.id()
data['client'] = client.dict_nodate()
data['feedback'] = None
feedback = Feedback.query(Feedback.client == self.client).get()
if feedback:
data['feedback'] = feedback.solo_dict()
return data
def delete_feedback(feedback_id):
"""POST /feedback/<feedback-id>/delete
Delete a specific piece of feedback and redirect to /users/<username> —
Make sure that only the user who has written that feedback can delete it
"""
curr_username = session.get('user')
if curr_username:
comment = Feedback.get(feedback_id)
if curr_username == comment.username:
comment.delete()
return redirect(f'/users/{curr_username}')
else:
return f"401! You're not authorized to do that {curr_username}!", 401
else:
flash("Log In Please.")
return redirect('/')
def select_all(self):
feedbacks = []
sql = f"SELECT * FROM {self.table}"
results = run_sql(sql)
for row in results:
owner = OwnerRep().select(row["owner_id"])
feedback = Feedback(
row["qos"],
row["fs"],
row["cf"],
row["recommend"],
row["suggestions"],
row["other_comment"],
owner,
row["id"],
)
feedbacks.append(feedback)
return feedbacks
def select(self, id):
feedback = None
sql = f"SELECT * FROM {self.table} " + "WHERE id = %s"
values = [id]
result = run_sql(sql, values)[0]
if result is not None:
owner = OwnerRep().select(result["owner_id"])
feedback = Feedback(
result["qos"],
result["fs"],
result["cf"],
result["recommend"],
result["suggestions"],
result["other_comment"],
owner,
result["id"],
)
return feedback
def post(self):
feedback_form = FeedbackForm()
if feedback_form.validate_on_submit():
user = User.query.filter_by(
username=session.get('username')).first()
new_feedback = Feedback(name=feedback_form.name.data,
category=feedback_form.category.data,
ivertinimas=feedback_form.ivertinimas.data,
description=feedback_form.description.data,
kodas=feedback_form.code.data,
user_id=user.id)
db.session.add(new_feedback)
db.session.commit()
return redirect(
url_for('feedback',
feedback_id=Feedback.query.order_by(
Feedback.id.desc()).first().id))
else:
return redirect(url_for('create_feedback'))
def feedback():
print(' not in POST')
if request.method == 'POST':
print('inside /feedback')
data = request.get_json(force=True)
name = data['name']
email = data['email']
subject = data['subject']
message = data['message']
print(name)
print(email)
print(subject)
print(message)
if email:
print(str(email))
feedback_user = Feedback(name, email, subject, message)
db.session.add(feedback_user)
db.session.commit()
else:
print('not email')
# unique email and also create one for deletion
return jsonify({'hello': 'world'})
return jsonify({'hello': 'world'})
def feedback(id):
recipient = User.get_by_id(id)
feedback_subject = request.form.get('formSubject')
feedback_message = request.form.get('formMessage')
Feedback(subject=feedback_subject,
message=feedback_message,
requester_id=current_user.id,
receiver_id=recipient.id,
answered=False).save()
Notification(notification_type=3,
sender=current_user.id,
recipient=recipient.id).save()
message = Mail(
from_email='*****@*****.**',
to_emails='*****@*****.**',
subject=feedback_subject,
html_content=
f'{feedback_message} <br /> <br /> From:{current_user.name}')
# The "to_emails" field above is hardcoded to "*****@*****.**"
# Please update it to "recipient.email" when the app is pushed to production.
try:
sg = SendGridAPIClient(os.environ.get('SENDGRID_API_KEY'))
response = sg.send(message)
print(response.status_code)
print(response.body)
print(response.headers)
except Exception as e:
print(str(e))
resp = {'success': True}
return jsonify(resp)
def post(self):
"""
store user feedbacks to the database
:return: operation results
"""
from models.feedback import Feedback, FeedbackContent
message = request.get_json(force=True)
try:
new_feedback = Feedback()
new_feedback_content = []
for each_content in message['data']:
feedback_content = FeedbackContent(**each_content)
new_feedback_content.append(feedback_content)
new_feedback.content = new_feedback_content
new_feedback.date = datetime.datetime.now()
new_feedback.save()
return send_json_response({}, 200)
except Exception as error:
return send_json_response({'msg': str(error)}, 500)
def newFeedbackForSurvey(surveyID):
# Creates a feedback record
# Stores the id to that record in a cookie
# Has respective view that shows the latest active survey
# Form dict
qtype_forms = {
'Freeform': AnswerFormFree(request.form),
'Thumbs': AnswerFormThumbs(request.form),
'Stars': AnswerFormStars(request.form),
'Smileys': AnswerFormSmileys(request.form),
'Choices': AnswerFormChoices(request.form),
'Picture': AnswerFormFree(request.form)
}
# From active surveys, get one with greatest id
survey = session.query(Survey).filter(Survey.id_ == surveyID,
Survey.enabled_).first()
if survey == None:
return 'No active surveys.'
# Check if valid cookie exists
feedback = None
try:
cookie = request.cookies['feedback_id']
if not (cookie == None or (request.cookies['survey_id'] != surveyID)):
# Fetch feedback with id_ == cookie from db
feedback = session.query(Feedback).filter_by(id_=cookie).one()
except:
pass
# If no valid cookie exists, create new feedback and new cookie with feedback id_ as value
if feedback == None or cookie == None or len(cookie) == 0:
feedback = Feedback(survey_id_=survey.id_)
session.add(feedback)
session.commit(
) # For some reason, feedback.survey_id_ is not yet entered into db. (((WHY)))
# Workaround to store feedback.survey_id_ into db: query, change, commit
feedback = session.query(Feedback).order_by(
Feedback.id_.desc()).first()
feedback.survey_id_ = survey.id_
session.add(feedback)
session.commit()
# Check that feedback.survey_id_ is now stored in db
feedback = session.query(Feedback).order_by(
Feedback.id_.desc()).first()
# Get list of survey questions
q_list = session.query(Question).filter_by(survey_id_=survey.id_).order_by(
Question.id_).all()
# Get first question
q, response = None, None
try:
q = q_list[0]
except:
return 'Survey has no questions. Thank you & goodbye.'
# Show first survey question:
if q != None:
template = templates.get(
q.type_,
'freeform.html') # Defaults to show_question_freeform for now
form = qtype_forms.get(q.type_, AnswerFormFree(
request.form)) # Defaults to AnswerFormFree for now
prev_url = None
next_url = url_for(
'controllers.thankYou') if len(q_list) <= 1 else url_for(
'controllers.showQuestion', question_id=q_list[1].id_)
progress = 0
response = make_response(
render_template('survey_frontpage.html',
survey=survey,
question_id=q.id_,
feedback=feedback,
progress=progress))
# Set cookie to value of feedback.id_
response.set_cookie('feedback_id', str(feedback.id_))
return response
def insert_feedback_for_talk(cls, talk_id, detail):
feedback = Feedback(detail, talk_id)
db.session.add(feedback)
db.session.commit()
evi_pet5 = Pet('Ditton', dt.date(2020, 2, 3), False, 'Cat', evi_obj,
melissa_obj, evi_pet5_img[0], evi_pet5_img[1])
pet_14 = PetRep().save(evi_pet5)
evi_pet6_img = read_file('pets_images_base64/pet-15.txt')
evi_pet6 = Pet('Jasmine', dt.date(2020, 2, 3), False, 'Cat', evi_obj,
melissa_obj, evi_pet6_img[0], evi_pet6_img[1])
pet_15 = PetRep().save(evi_pet6)
evi_pet7_img = read_file('pets_images_base64/pet-16.txt')
evi_pet7 = Pet('Inka', dt.date(2020, 2, 3), False, 'Dog', evi_obj, melissa_obj,
evi_pet7_img[0], evi_pet7_img[1])
pet_16 = PetRep().save(evi_pet7)
# FEEDBACKS
feedback1 = Feedback(4, 3, 4, 3, 'Not really', 'Great job', marios_obj)
FeedbackRep().save(feedback1)
feedback2 = Feedback(4, 3, 4, 3, 'You could lower the prices', 'Nice staff',
maria_obj)
FeedbackRep().save(feedback2)
feedback3 = Feedback(4, 3, 4, 3, 'What about doing...', 'An amazing job',
evi_obj)
FeedbackRep().save(feedback3)
feedback4 = Feedback(4, 3, 4, 3, 'Not really', 'Great job', lola_obj)
FeedbackRep().save(feedback4)
feedback5 = Feedback(4, 3, 4, 3, 'Not really', 'Great job', kost_obj)
FeedbackRep().save(feedback5)
def newFeedback():
# Creates a feedback record
# Stores the id to that record in a cookie
# Has respective view that shows the latest active survey
print('\n--- ENTERING newFeedback, method: {}'.format(request.method))
# Question types dict
qtype_forms = {
'Freeform': AnswerFormFree(request.form),
'Thumbs': AnswerFormThumbs(request.form),
'Stars': AnswerFormStars(request.form),
'Smileys': AnswerFormSmileys(request.form),
'Choices': AnswerFormChoices(request.form)
}
print('---FORM DICT: {}'.format(qtype_forms))
# From active surveys, get one with greatest id
survey = session.query(Survey).filter(
Survey.end_date_ >= datetime.datetime.now(),
Survey.enabled_).order_by(Survey.id_.desc()).first()
if survey != None:
print('--- FOUND SURVEY ID {}, TITLE {}'.format(
survey.id_, survey.description_))
else:
return 'No active surveys.'
# Check if valid cookie exists
feedback = None
try:
cookie = request.cookies['feedback_id']
if cookie == None:
print('---FOUND COOKIE WITH VALUE None')
else:
# Fetch feedback with id_ == cookie from db
feedback = session.query(Feedback).filter_by(id_=cookie).one()
if feedback.survey_id_ == survey.id_:
print(
'---FOUND VALID COOKIE WITH FEEDBACK_ID {} CONNECTED TO SURVEY {}'
.format(cookie, survey.id_))
else:
print('---FOUND INVALID COOKIE FOR THIS SURVEY:')
except:
pass
# If no valid cookie exists, create new feedback and new cookie with feedback id_ as value
if feedback == None or cookie == None or len(cookie) == 0:
print(
'--- NO COOKIE FOUND. CREATING NEW FEEDBACK RECORD FOR THIS SURVEY...'
)
feedback = Feedback(survey_id_=survey.id_)
session.add(feedback)
session.commit(
) # For some reason, feedback.survey_id_ is not yet entered into db. (((WHY)))
# Workaround to store feedback.survey_id_ into db: query, change, commit
feedback = session.query(Feedback).order_by(
Feedback.id_.desc()).first()
feedback.survey_id_ = survey.id_
session.add(feedback)
session.commit()
# Check that feedback.survey_id_ is now stored in db
feedback = session.query(Feedback).order_by(
Feedback.id_.desc()).first()
print('---CREATED FEEDBACK ENTRY {}'.format(feedback.serialize))
print('--- COOKIE / SESSION ID WILL BE SET TO: {}'.format(
feedback.id_))
else:
print('---FEEDBACK WAS NOT NONE, IT\'S: {}'.format(feedback.serialize))
# Get list of survey questions
q_list = session.query(Question).filter_by(survey_id_=survey.id_).order_by(
Question.id_).all()
print('---QUESTIONS FOR SURVEY {}: {}, len {}'.format(
survey.id_, q_list, len(q_list)))
# Get first question
q, response = None, None
try:
q = q_list[0]
except:
return 'Survey has no questions. Thank you & goodbye.'
# Show first survey question:
if q != None:
template = templates.get(
q.type_,
'freeform.html') # Defaults to show_question_freeform for now
form = qtype_forms.get(q.type_, AnswerFormFree(
request.form)) # Defaults to AnswerFormFree for now
prev_url = None
next_url = url_for(
'controllers.thankYou') if len(q_list) <= 1 else url_for(
'controllers.showQuestion', question_id=q_list[1].id_)
progress = 0
# Debug statements
print('---QUESTION TYPE: {}'.format(q.type_))
print('---TEMPLATE: {}, {}'.format(type(template), template))
print('---FORM: {}, {}'.format(type(form), form))
print('---FIRST QUESTION_ID: {}, {}'.format(type(q.id_), q.id_))
print('---QUESTION_TITLE: {}, {}'.format(type(q.title_), q.title_))
print('---NEXT_URL: {}, {}'.format(type(next_url), next_url))
print('---PREV_URL: {}, {}'.format(type(prev_url), prev_url))
# flash('Feedback_id == Cookie == {}'.format(feedback.id_))
# flash('progress: {}'.format(progress))
response = make_response(
render_template('survey_frontpage.html',
survey=survey,
question_id=q.id_,
feedback=feedback,
progress=progress))
# Set cookie to value of feedback.id_
response.set_cookie('feedback_id', str(feedback.id_))
print(
'---RESPONSE CREATED. EXITING newFeedback AND RENDERING survey_frontpage.html: {}'
.format(response))
return response
q3_c2 = QuestionChoice(title_="2", question_id_=3)
q3_c3 = QuestionChoice(title_="3", question_id_=3)
q3_c4 = QuestionChoice(title_="4", question_id_=3)
q3_c5 = QuestionChoice(title_="5", question_id_=3)
# Survey 1 Q2
q4 = Question(type_='Smileys',
title_="Q2: Air quality",
survey_id_=1,
optional_=True)
q4_c1 = QuestionChoice(title_="frown", question_id_=3)
q4_c2 = QuestionChoice(title_="meh", question_id_=3)
q4_c3 = QuestionChoice(title_="incredible", question_id_=3)
# Feedbacks
fb_1 = Feedback(survey_id_=1)
fb_2 = Feedback(survey_id_=1)
fb_3 = Feedback(survey_id_=1)
fb_4 = Feedback(survey_id_=1)
# Answers from first feedback (survey was 1)
a_f1_q1 = Answer(value_=q1_c1.title_, feedback_id_=1, question_id_=1)
a_f1_q2 = Answer(value_='Wow, I feel fabulous, thank you!',
feedback_id_=1,
question_id_=2)
# Answers from second feedback (survey was 1)
a_f2_q1 = Answer(value_=q1_c2.title_, feedback_id_=2, question_id_=1)
a_f2_q2 = Answer(value_='I feel miserable. The bus ride ruined my day.',
feedback_id_=2,
question_id_=2)
def message(id):
get_message = Feedback.get_by_id(id)
if get_message:
return jsonify(get_message.message)
else:
return False
def get(self, id):
idea = Idea.get_by_id(int(id))
if(idea):
extended_idea = Idea.get_extended_idea(idea)
author = User.get(Idea.author.get_value_for_datastore(idea))
feedback = None
if(self.current_user):
feedback = Feedback.all().filter("author =", self.current_user.key()).filter("idea =", idea.key()).get()
# Fetch comments
comments = Comment.all().filter('idea = ', idea.key()).fetch(1000)
# Filter comments which are not replies to and those from the others
threaded, children, depths = [], [], []
for comment in comments:
if Comment.reply_to.get_value_for_datastore(comment) is None:
threaded.append(comment)
depths.append(0)
else:
children.append(comment)
# Filter comments which are not replies to by date (desc)
tosort = [(c.created, c) for c in threaded]
tosort.sort()
tosort.reverse()
threaded = [c for _, c in tosort]
# Filter children by date (asc)
tosort = [(c.created, c) for c in children]
tosort.sort()
children = [c for _, c in tosort]
# Insert children comments at the right place
for comment in children:
i = 0
parents = list(threaded)
for parent in parents:
if parent.key() == Comment.reply_to.get_value_for_datastore(comment):
threaded.insert(1 + i, comment)
depths.insert(1 + i, depths[i] + 1)
i = i + 2
else:
i = i + 1
# Get authors
authors_keys = [Comment.author.get_value_for_datastore(c) for c in threaded]
authors = User.get(authors_keys)
values = {
"extended_idea": extended_idea,
"author": author,
"feedback": feedback,
"comments": zip(authors, threaded, depths),
}
path = "idea/idea.html"
self.render(path, values)
else:
raise GetpitchdError("Idea does not exist")
def post(self, id):
idea = Idea.get_by_id(int(id))
if(idea):
content = self.request.get("feedback")
if(content=="positive" or content=="negative"):
key_name = str(self.current_user.key().id()) + "_" + str(idea.key().id())
existing_feedback = Feedback.get_by_key_name(key_name)
if not existing_feedback:
feedback = Feedback(
key_name = key_name,
author = self.current_user.key(),
idea = idea.key(),
content = content,
)
feedback.put()
if(content == "positive"):
idea.positive += 1
else:
idea.negative += 1
text = self.request.get("text")
if text:
comment = Comment(
idea = idea.key(),
author = self.current_user.key(),
text = text,
)
comment.put()
idea.comments += 1
idea.put()
if text:
event = IdeaFeedbackEvent(self.current_user, feedback, idea, text)
else:
event = IdeaFeedbackEvent(self.current_user, feedback, idea)
if(content == "positive"):
author_key = Idea.author.get_value_for_datastore(idea)
author = User.get(author_key)
text = "I'm enthusiastic about a new startup idea pitched by @" + author.username + " on @gopitchme: " + idea.title
url = config.SITE_URL + "/idea/" + str(idea.key().id())
tweet = generate_tweet(text, url)
response = "Feedback sent"
call_to_action = "Why not tweeting this idea to your friends?"
values = {
"response": response,
"call_to_action": call_to_action,
"tweet": tweet,
"skip_url": "/idea/" + str(idea.key().id()),
}
path = "idea/tweet.html"
else:
values = {
"response": "Thanks for your feedback",
"next": {
"content": "Back",
"url": "/idea/"+str(idea.key().id()),
}
}
path = "feedback.html"
self.render(path, values)
else:
raise GetpitchdError("Feedback already sent")
else:
raise GetpitchdError("Forbidden feedback")
else:
raise GetpitchdError("Idea does not exist")
def get(self):
"""
return the statistical information
query across feedback and prediction model
:return: return statistical information
"""
from models.prediction import Prediction
from models.feedback import Feedback
prediction_collection = Prediction._get_collection()
feedback_collection = Feedback._get_collection()
statistical_data = copy.deepcopy(CONSTANTS['STATISTICAL_DATA'])
# initial statistical_data based on age and ascending order
total_age = []
for i in range(21):
total_age.append(str(i * 5) + '+')
for each_age in total_age:
statistical_data['prediction_data']['age'][each_age] = 0
statistical_data['feedback_data']['age']['wrong'][each_age] = 0
statistical_data['feedback_data']['age']['correct'][each_age] = 0
# photo by date
today = datetime.datetime.today().replace(hour=0,
minute=0,
second=0,
microsecond=0)
total_number_of_photo_within_one_week = {
(today - datetime.timedelta(days=6)).strftime('%d/%m/%Y'):
prediction_collection.count_documents({
'date': {
'$lt': today - datetime.timedelta(days=5),
'$gte': today - datetime.timedelta(days=6)
}
}),
(today - datetime.timedelta(days=5)).strftime('%d/%m/%Y'):
prediction_collection.count_documents({
'date': {
'$lt': today - datetime.timedelta(days=4),
'$gte': today - datetime.timedelta(days=5)
}
}),
(today - datetime.timedelta(days=4)).strftime('%d/%m/%Y'):
prediction_collection.count_documents({
'date': {
'$lt': today - datetime.timedelta(days=3),
'$gte': today - datetime.timedelta(days=4)
}
}),
(today - datetime.timedelta(days=3)).strftime('%d/%m/%Y'):
prediction_collection.count_documents({
'date': {
'$lt': today - datetime.timedelta(days=2),
'$gte': today - datetime.timedelta(days=3)
}
}),
(today - datetime.timedelta(days=2)).strftime('%d/%m/%Y'):
prediction_collection.count_documents({
'date': {
'$lt': today - datetime.timedelta(days=1),
'$gte': today - datetime.timedelta(days=2)
}
}),
(today - datetime.timedelta(days=1)).strftime('%d/%m/%Y'):
prediction_collection.count_documents({
'date': {
'$lt': today,
'$gte': today - datetime.timedelta(days=1)
}
}),
today.strftime('%d/%m/%Y'):
prediction_collection.count_documents({'date': {
'$gte': today
}}),
}
# prediction
total_prediction = prediction_collection.find({})
for each_prediction in total_prediction:
prediction_results = each_prediction['predictionResults']
for each_result in prediction_results:
statistical_data['prediction_number'] = statistical_data.get(
'prediction_number', 0) + 1
# age, gender, emotion
each_age = str(5 * math.floor(each_result['age'] / 5)) + '+'
statistical_data['prediction_data']['age'][each_age] = \
statistical_data['prediction_data']['age'].get(each_age, 0) + 1
statistical_data['prediction_data']['gender'][each_result['gender']] = \
statistical_data['prediction_data']['gender'].get(each_result['gender'], 0) + 1
statistical_data['prediction_data']['emotion'][each_result['emotion']] = \
statistical_data['prediction_data']['emotion'].get(each_result['emotion'], 0) + 1
# feedback
total_feedback = feedback_collection.find({})
for each_feedback in total_feedback:
feedback_content = each_feedback['content']
for each_content in feedback_content:
statistical_data['feedback_number'] = statistical_data.get(
'feedback_number', 0) + 1
# age
if each_content['ageCorrectness'] == False:
statistical_data['feedback_data']['age']['wrong'][
each_content['ageFeedback']] = \
statistical_data['feedback_data']['age'][
'wrong'].get(each_content['ageFeedback'], 0) + 1
else:
statistical_data['feedback_data']['age']['correct'][
each_content['ageFeedback']] = \
statistical_data['feedback_data']['age']['correct'].get(
each_content['ageFeedback'], 0) + 1
# gender
if each_content['genderCorrectness'] == False:
statistical_data['feedback_data']['gender']['wrong'][
each_content['genderFeedback']] = \
statistical_data['feedback_data']['gender'][
'wrong'].get(each_content['genderFeedback'], 0) + 1
else:
statistical_data['feedback_data']['gender']['correct'][
each_content['genderFeedback']] = \
statistical_data['feedback_data']['gender']['correct'].get(
each_content['genderFeedback'], 0) + 1
if each_content['emotionCorrectness'] == False:
statistical_data['feedback_data']['emotion']['wrong'][
each_content['emotionFeedback']] = \
statistical_data['feedback_data']['emotion']['wrong'].get(
each_content['emotionFeedback'], 0) + 1
else:
statistical_data['feedback_data']['emotion']['correct'][
each_content['emotionFeedback']] = \
statistical_data['feedback_data']['emotion']['correct'].get(
each_content['emotionFeedback'], 0) + 1
result = {
'totalNumberOfPhotoUploaded':
prediction_collection.count_documents({}),
'totalNumberOfPrediction':
statistical_data['prediction_number'],
'totalNumberOfFeedback':
statistical_data['feedback_number'],
'totalNumberOfAgePrediction':
statistical_data['prediction_data']['age'],
'totalNumberOfAgeCorrectFeedback':
statistical_data['feedback_data']['age']['correct'],
'totalNumberOfAgeWrongFeedback':
statistical_data['feedback_data']['age']['wrong'],
'totalNumberOfGenderPrediction':
statistical_data['prediction_data']['gender'],
'totalNumberOfGenderCorrectFeedback':
statistical_data['feedback_data']['gender']['correct'],
'totalNumberOfGenderWrongFeedback':
statistical_data['feedback_data']['gender']['wrong'],
'totalNumberOfEmotionPrediction':
statistical_data['prediction_data']['emotion'],
'totalNumberOfEmotionCorrectFeedback':
statistical_data['feedback_data']['emotion']['correct'],
'totalNumberOfEmotionWrongFeedback':
statistical_data['feedback_data']['emotion']['wrong'],
'numberOfPhotoByDate':
total_number_of_photo_within_one_week
}
return send_json_response(result, 200)
