def add_answer(get_data):
	'''
	@summary: to add multi-choice answer
	@param: <data> answer data dictionary
	'''
	data = {}
	answer_text = get_data.get('answer_text')
	answer_rating = get_data.get('answer_rating','')
	presentation_order = get_data.get('presentation_order')
	question_id = get_data.get('question_id')
	status_cd = get_data.get('status_cd')
	created_by = get_data.get('created_by')
	now_date = datetime.now()
	if answer_text and answer_rating and presentation_order.isdigit() and question_id and status_cd and created_by:
		answer_data = Answer(
			answer_text = answer_text,
			answer_rating = answer_rating,
			presentation_order = presentation_order,
			question_id = question_id,
			status_cd = status_cd,
			created_by = created_by,
			updated_by = created_by,
			created_date = now_date,
			updated_date = now_date)
			
		answer_data.save()
		data['status'] = 1
		data['msg'] = 'Answer Added succssfully'
		data['data'] = {'question_id': answer_data.question_id, 'answer_id': answer_data.answer_id}
	else:
		data['status'] = 0
		data['msg'] = 'Some fields are missing'
	return data

 def save(self):
     question = Question.objects.get(pk=self.cleaned_data.get('question'))
     answer = Answer(text = self.cleaned_data['text'],
                     question=question,
                     author=self._user)
     answer.save()
     return answer

def receive_ans_ajax(request, round_number):
    if request.is_ajax() and request.method == 'POST':
        json_data = json.loads(request.readline())
        
        player = request.user.player
        
        room_query = GameRoom.objects.filter(players__id=player.id)
        room = room_query[0]

        round_query = GameRound.objects.filter(room__id=room.id)
        cur_round = round_query.filter(round_number=round_number)[0]

        for key in json_data:
            value = json_data[key]
            field_query = Field.objects.filter(short_name=key)
            field = field_query[0]
            if len(value) >0:
                valid = value[0].lower() == cur_round.cur_letter.lower()
            else:
                valid = False

            ans = Answer(roundd=cur_round, player=player, field=field, ans=value, valid=valid,points= 10 if valid else 0 )
            ans.save()
        return HttpResponse("OK")
    else:
        if not request.is_ajax():
            return HttpResponse('Only ajax is allowed')
        elif not request.method == 'POST':
            return HttpResponse(request.method + ' is not allowed')
        else:
            return HttpResponse('unknown error')

 def save(self, user_id):
     user = User.objects.get(id=user_id)
     self.cleaned_data['author'] = user
     question = Question.objects.get(id=self.cleaned_data['question'])
     self.cleaned_data['question'] = question
     answer = Answer(**self.cleaned_data)
     answer.save()
     return answer

 def save(self):
     if self._user.is_anonymous():
         self.cleaned_data['author_id'] = 1
     else:
         self.cleaned_data['author'] = self._user
     answer = Answer(**self.cleaned_data)
     answer.save()
     return answer

 def save(self):
     if self._user.is_authenticated():
         self.cleaned_data['author'] = self._user
     url = '/question/'+ str(self.cleaned_data['question'])+'/' # bad pracrtice hardcoded link
     self.cleaned_data['question'] = Question.objects.get(id=self.cleaned_data['question'])
     answer = Answer(**self.cleaned_data)
     answer.save()
     return url

 def post(self, boragle_slug, question_slug):
     question = Question.find_by_slug(question_slug)
     avatar = self.get_avatar_for_boragle(question.boragle)
     assert avatar, question
     answer = self.read('answer')
     if not(answer and answer.strip()): raise PostingError('Please provide an answer')
     Answer.create(question = question, text = answer, creator = avatar)
     page = self.calc_last_page(question.answer_count, settings.answer_page_size)
     self.redirect(question.url+'?page='+str(page))

 def test_voting_security(self):
     answer = Answer.create(question = self.question, text= 'fake answer', creator = self.avatar)
     self.app.get(answer.voting_url+'/up', status = 302)
     answer = Answer.get(answer.key())
     self.assertEqual(answer.vote_count, 1)
     self.logout()
     self.app.get(answer.voting_url+'/down', status = 302)
     answer = Answer.get(answer.key())
     self.assertEqual(answer.vote_count, 1)        

 def save(self):
     # getting Question by ID
     print 'AnswerF save: %s (%s)' % ( self.cleaned_data, self.cleaned_data['question'])
     q_id = int(self.cleaned_data['question'])
     quest = Question.objects.get(id = q_id)
     #ans = Answer(**self.cleaned_data)
     ans = Answer(text = self.cleaned_data['text'])
     ans.author_id = 1
     quest.answer_set.add(ans)
     quest.save()
     return ans

def createQuestion(match_id):
    player_id = request.form['player_id']
    correct = request.form['correct'] == '1'
    tags = request.form.getlist('tags[]')

    answer = Answer(player_id, correct)
    question = Question(tags, answers=[answer.asJSON()])
    question.save()

    match = MatchFinder().find(match_id)
    match.addQuestionAndAnswer(question, answer)
    return "OK " + str(question._id)

def question(request):
    if request.method == 'POST' :
        req = simplejson.loads(request.body,strict=False)
        # get the json parameters,username,course,questionnumber and answer
        username = req['username']
        course = req['course']
        role = req['role']
        quetionnumber = req['questionnumber']
        answer = req['answer']
        #check the parameter validating
        #store to the db
        ans = Answer(question_id = questionnumber, course_id = course,text = answer)
        ans.save()

 def run(self):
     Answer.query.delete()
     db.session.commit()
     for file_name in glob(os.path.join(ANSWERS_DIR, '**/*.csv')):
         with open(file_name, 'rb') as csvfile:
             locale = file_name.split('/')[-2]
             csv_reader = csv.reader(csvfile)
             for row in csv_reader:
                 answer = Answer()
                 answer.locale = locale
                 answer.text = unicode(row[0], 'utf-8')
                 db.session.add(answer)
             db.session.commit()

def set_answer(puzzle_name, player_id, question, content_type, content):
    player = Player.get(Player.id == player_id)
    puzzle, _ = Puzzle.get_or_create(name=puzzle_name)
    try:
        answer = Answer.get(
            (Answer.puzzle == puzzle) & (Answer.player == player))
    except Answer.DoesNotExist:
        answer = Answer(puzzle=puzzle, player=player)

    answer.question = question

    if content_type == 'text':
        answer.value = content
    elif content_type == 'image':
        filename = '%s_%s.jpg' %  (puzzle.id, player.id)
        path = '%s/images/%s' % (STATIC_DIR, filename)
        with open(path, 'wb') as fp:
            fp.write(content)
        answer.value = 'image:' + filename
    elif content_type == 'video':
        filename = '%s_%s.mp4' %  (puzzle.id, player.id)
        path = '%s/videos/%s' % (STATIC_DIR, filename)
        with open(path, 'wb') as fp:
            fp.write(content)
        answer.value = 'video:' + filename

    answer.save()

def filldb(request, cou):
    for x in range(0, int(cou)):
        q = Question(title = "Question #"+str(x),
                     text = "Just a question with number "+str(x))
        q.rating = x
        q.author_id = 1
        q.added_at = date(2016, 03, 1+x)
        q.save()
        q.added_at = date(2016, 03, 1+x)
        for y in range(1, x+2):
            a = Answer(text = "answer #"+str(y)+" for question #"+str(x))
            a.author_id = 1
            q.answer_set.add(a)
        q.save()
    return HttpResponse("OK")

def user_profile():
    """Displays the user profile page"""
    user = users.get_current_user()
    question_count = Question.count_for(user)
    answer_count = Answer.count_for(user)
    form = ProspectiveUserForm()
    all_prospective_users = ProspectiveUser.get_for(user)
    prospective_user = all_prospective_users.get()

    if request.method == 'POST':
        if prospective_user is None:
            prospective_user = ProspectiveUser (
                login = user,
                origin_location = get_location(form.origin_location.data),
                notification_radius_in_km = form.notification_radius_in_km.data,
                screen_name = form.screen_name.data
            )
        else:
            prospective_user.origin_location = get_location(form.origin_location.data)
            prospective_user.notification_radius_in_km = form.notification_radius_in_km.data
            prospective_user.screen_name = form.screen_name.data
        try:
            prospective_user.put()
            subscribe_user_for_nearby_questions(prospective_user.key.id())
            flash(u'Home location successfully saved.', 'success')

            return redirect(url_for('user_profile'))
        except CapabilityDisabledError:
            flash(u'App Engine Datastore is currently in read-only mode.', 'info')
            return redirect(url_for('user_profile'))

    return render_template('user_profile.html', user=user, prospective_user=prospective_user,
                           question_count=question_count, answer_count=answer_count, form=form)

def get_rev_set_raw(rev):
    qs = []
    #first object to be the description of the revision
    lect_class = LectClass.get(rev.lect_class)
    rev_desc = {
                'lecturer':rev.user.name,
                'institution':rev.user.institution,
                'title':rev.title,
                'class':lect_class.name,
                'description':rev.description,
                'created':rev.created.strftime("%B %d, %Y")
                }
    qs.append(rev_desc)
    questions = Question.gql('WHERE revision = :1',rev).fetch(100) #how do we fetch all the Qs?
    for q in questions:
        answers = Answer.gql('WHERE question=:1',q)
        ans = []
        for a in answers:
            ans.append(a.answer)
        question = {
                    'question':q.question.replace("\n","").replace("\r",""),
                    'answers':ans
                    }
        qs.append(question)
    return qs

def answer_question(request, question_id):
    if request.user.is_authenticated():
        if request.method == 'POST':
            form = AnswerForm(request.POST)
            if form.is_valid():
                question = Question.objects.get(id = question_id)
                author = request.user
                text = form.cleaned_data['answer']
                answer = Answer(text = text, author = author,
                        question = question)
                answer.save()
                return  view_question(request, question_id)
            else:
                pass #TODO: validar cuando el formulario de errores.
    else:
        return HttpResponseRedirect('/cuentas/login')

def handleForm(request):
    new_title = request.POST['title']
    new_author = request.POST['author']
    new_desc = request.POST['desc']
    answers = []
    for i in range(1, 20):
        input_name = "answer" + str(i)
        if input_name in request.POST:
            s = request.POST[input_name].replace("'", "")
            answers.append(s)
    new_survey = Survey(title=new_title, author=new_author, desc=new_desc)
    new_survey.save()
    for answer in answers:
        new_answer = Answer(survey=new_survey, text=answer, votes=0)
        new_answer.save()
    return HttpResponseRedirect('/survey/' + str(new_survey.id))

def reply_question(question_id):
	user_id = session['user_id']
	data = json.loads(request.data)
	data['author_id'] = user_id
	data['question_id'] = question_id
	
	answer = Answer(**data)
	result = answer.save()
	
	if result:
		answer = answer.to_dict()
		author = User.query.get(user_id).to_dict()
		answer['author'] = author
		socketio.emit('question' + str(question_id), answer, namespace='/qa')
	
	return jsonify({'status': 1 if result else 0})

 def save(self, commit=True):
     test = super(TestAdminForm, self).save(False)
     file = self.cleaned_data['file']
     questions_count = self.cleaned_data['questions_count']
     
     if file:
         test_name = test.name
         test.save()
         AnswerResult.objects.filter(answer__question__test=test).delete()
         AnswerChoice.objects.filter(question__test=test).delete()
         TestPass.objects.filter(test=test).delete()
         Answer.objects.filter(question__test=test).delete()
         Question.objects.filter(test=test).delete()
         
         questions = parser(file)
         count = 0
         cur_test = test
         
         for i, question in enumerate(questions):
             count += 1
             q = Question(test=cur_test, question=question['question'])
             if question['text_answer']:
                 q.text_answer = question['text_answer']
                 q.save()
             else:
                 q.save()
                 for answer in question['answers']:
                     a = Answer(question=q)
                     a.answer = answer['text']
                     a.correct = answer['correct']
                     a.save()
             
             if questions_count and count >= questions_count:
                 if (len(questions) - i) >= questions_count:
                     cur_test.name = '%s [%s-%s]' % (test_name, i+1-count, i+1)
                     cur_test.save()                           
                     cur_test = copy(test)
                     cur_test.pk = None
                     cur_test.save()
                 else:
                     cur_test.name = '%s [%s-%s]' % (test_name, i+1-count, len(questions))
                     cur_test.save()
                                                   
                 count = 0
             
     return test