Python models.Answer类代码示例

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)