예제 #1
0
 def test_choice_str(self):
     time = timezone.now()
     question = Question(pub_date=time)
     choice = Choice()
     choice.question = question
     choice.choice_text = 'Choice1'
     self.assertEqual(str(choice), 'Choice1')
예제 #2
0
    def handle(self, *args, **options):
        # delete Questionnaire.objects.filter(id__gt=3).delete()
        # reset index ALTER TABLE table_name AUTO_INCREMENT = 1;
        gene_time = options['gene_num']
        origin_count = Questionnaire.objects.count()
        for i in range(gene_time):
            polls_orders = origin_count + i + 1
            print(polls_orders)
            pub_date = timezone.now() - datetime.timedelta(days=(400 - i))
            questionnaire = Questionnaire(
                questionnaire_name="测试问卷{}".format(polls_orders),
                pub_date=pub_date,
                detail_info="用于测试的问卷")
            questionnaire.save()
            for j in range(4):
                question = Question(question_text="测试问题{}".format(j + 1),
                                    question_type=1,
                                    questionnaire=questionnaire)
                question.save()
                for k in range(4):
                    choice = Choice(choice_text="测试选项{}".format(k + 1),
                                    votes=random.randint(50, 200),
                                    question=question)
                    choice.save()

            self.stdout.write(
                self.style.SUCCESS('Successfully generate test questionnaire'))
class VoteTests(base.BaseTestCase):

    def setUp(self):
        super().setUp()

        self.question = Question.objects.create(
            question_text='Is this a test?',
            pub_date=timezone.now()
        )
        self.question.save()

        self.choice1 = Choice(
            question=self.question,
            choice_text='No',
            votes=0,
        )
        self.choice1.save()

        self.choice2 = Choice(
            question=self.question,
            choice_text='Yes',
            votes=0,
        )
        self.choice2.save()

    def test_view(self):
        url = reverse('polls:vote', args=(self.question.id,))
        request = self.request_factory.post(url, {'choice': self.choice2.id})
        response = vote(request, self.question.id)

        self.assertEqual(response.status_code, 302)
        self.assertEqual(response.url, reverse('polls:results', args=(self.question.id,)))
def get_question(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 = QuestionForm(request.POST)
        # check whether it's valid:
        if form.is_valid():
            question_body = request.POST.get('your_question', '')
            new_question = Question(question_text=question_body, pub_date=timezone.now())
            new_question.save()

            characters = ['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w',
                          'x','y','z']
            for i in range(0, 5):
                answer_text = 'your_answer_' + characters[i]
                new_answer = request.POST.get(answer_text, '')
                if new_answer != '':
                    new_choice = Choice(question=new_question, choice_text=new_answer, votes=0)
                    new_choice.save()
            # process the data in form.cleansed_data as required
            # ...
            # redirect to a new URL:
            return HttpResponseRedirect('/polls/')

    # if a GET (or any other method) we'll create a blank form
    else:
        form = QuestionForm()

    return render(request, 'polls/question.html', {'form': form})
예제 #5
0
 def test_choice_str(self):
     time = timezone.now()
     question = Question(pub_date=time)
     choice = Choice()
     choice.question = question
     choice.choice_text = 'Choice1'
     self.assertEqual(str(choice), 'Choice1')
def generate_elements(count=1):
    """
    this guy generates db elements for testing
    """
    for k in range(count):
        question = ""

        for i in range(choice((2, 3, 4, 5, 6, 7))):
            question = " ".join((question, choice(WORDS)))

        question = question[1:] + "?"
        question = question[0].upper() + question[1:]
        q = Question(question_text=question, pub_date=timezone.now())
        q.save()
        print(q.id, q.question_text)

        for choicecount in range(choice((2, 3))):
            choicetxt = ""

            for choicewords in range(choice((2, 3, 4, 5))):
                choicetxt = " ".join((choicetxt, choice(WORDS)))

            choicetxt = choicetxt[1:]
            choicetxt = choicetxt[0].upper() + choicetxt[1:] + "."
            # print('\t', choicetxt)

            ch = Choice(question=q, choice_text=choicetxt, votes=choice((0, 1, 2, 3, 4, 5)))
            ch.save()

            print("\t", ch.question.id, ch.choice_text)
예제 #7
0
파일: views.py 프로젝트: mcpanic/tedy-vote
def add_choice(request, poll_id):
    p = get_object_or_404(Poll, pk=poll_id)
    try:
        new_choice = Choice(    poll = p,
                choice_text = request.POST['choice_text'],
                choice_desc = request.POST['choice_desc'],
                proposer = request.POST['proposer'],
                votes = 1
               );
        new_choice.save()
    except IntegrityError:
        return render(request, 'polls/detail.html', {
            'poll': p,
            'error_propose_message': request.POST['choice_text'] + u": 이미 존재하는 이름입니다.",
        })

    try:
        if 'suggest_subscribe_check' in request.POST.keys():
            subscribe_check = True
        else:
            subscribe_check = False
        new_voter = Voter(poll=p, 
                    choice=new_choice, 
                    email=request.POST['proposer'], 
                    subscription=subscribe_check)
        new_voter.save()
    except Exception as err:
        print err.message, type(err)

    # Always return an HttpResponseRedirect after successfully dealing
    # with POST data. This prevents data from being posted twice if a
    # user hits the Back button.
    #return HttpResponseRedirect(reverse('results', args=(p.id,)))
    return render(request, 'polls/results.html', {'poll': p})
예제 #8
0
def add_poll(request):
    if request.method == 'POST':
        form = PollForm(request.POST)
        if form.is_valid():
            new_poll = form.save(commit=False)
            new_poll.owner = request.user
            new_poll.pub_date = datetime.datetime.now()
            new_poll.save()
            new_choice1 = Choice(
                poll=new_poll,
                choice_text=form.cleaned_data['choice1']).save()
            new_choice2 = Choice(
                poll=new_poll,
                choice_text=form.cleaned_data['choice2']).save()

            messages.success(
                request,
                'Poll and Choices Added!',
                extra_tags='alert alert-success alert-dismissible fade show')
            return redirect('polls:list')

    else:
        form = PollForm()
    context = {'form': form}
    return render(request, 'polls/add_poll.htm', context)
예제 #9
0
    def test_vote_answer_type_ONE(self):
        Poll.objects.create(
            name='Test_ONE', question='question1',
            begin_date=timezone.now(),
            end_date=timezone.now()+timezone.timedelta(minutes=1),
            answer_type='ONE'
        )

        poll = Poll.objects.get(name='Test_ONE')
        poll.choice_set.add(Choice(choice_text='ans1', created=timezone.now()))
        poll.choice_set.add(Choice(choice_text='ans2', created=timezone.now()))
        poll.choice_set.add(Choice(choice_text='ans3', created=timezone.now()))

        choices = poll.get_ordered_choices()

        self._common_test_for_ONE_and_MANY(poll, choices)

        response = self.client.post(
            '/polls/%s/vote/' % poll.id,
            {
                'choice': [choices[1].id, choices[2].id],
            },
            follow=True
        )

        messages = list(response.context['messages'])
        self.assertEqual(len(messages), 1)
        self.assertEqual('Вы должны выбрать один вариант ответа',
                         str(messages[0]))
        self._check_results(choices, self._last_results)
예제 #10
0
 def test_unicode(self):
   """
   __unicode__ should return the text of choice
   """
   poll = create_poll(question='Poll', days=-5)
   choice = Choice(poll=poll, choice_text='Awesome!', votes=5)
   self.assertEqual(choice.__unicode__(), 'Awesome!')
예제 #11
0
 def setUpClass(cls):
     u = User.objects.create_user('simeon', '*****@*****.**', 'password')
     p = Poll(user=u, question="Why?", pub_date=dt.now())
     p.save()
     Choice.objects.bulk_create([
         Choice(poll=p, choice="Because", votes=0),
         Choice(poll=p, choice="Because", votes=0)
     ])
     cls.p = p
예제 #12
0
def question_page(request, question_pk):
    question = Question.objects.get(pk=question_pk)

    if request.method == 'POST':
        answer = request.POST['answer']
        choice = Choice(question=question, choice_text=answer)
        choice.save()

    return render(request, 'question_detail.html', context={'question': question})
예제 #13
0
    def _create_choices(self):
        question = Question.objects.get(id=1)
        Choice(question=question, choice_text='Billy Eyelash').save()
        Choice(question=question, choice_text='BLACKPINK').save()
        Choice(question=question, choice_text='Clairo').save()
        Choice(question=question, choice_text='Dua Lipa').save()
        Choice(question=question, choice_text='Taylor Swift').save()

        print("***** ADDING TEST CHOICES TO THE DATABASE *****")
예제 #14
0
파일: views.py 프로젝트: pelos/restaurants
def vote(request):
    #we need to check if its before 4pm
    if request.method == "POST":
        form = polls.forms_DK.NameForm(request.POST)
        if form.is_valid():
            your_email = form.cleaned_data["your_email"]
            ratio = str(form.cleaned_data["ratio"])
            django.setup()

            timer_split = get_timer()
            dater = timer_split[0]
            hrs = timer_split[1]
            # we check if the user exists in the database.
            try:
                checking_email = Person.objects.get(email=your_email)
            except:
                address = "registration/"
                return HttpResponseRedirect(address)

            #Checking if its before 4pm cut_hour
            if datetime.datetime.now() < cut_hour:
                print "you can still vote"
                #quering to see if the person voted
                date_query = Choice.objects.filter(date_vote=dater)
                voted = False
                for i in date_query:
                    if i.person_id == checking_email.id:
                        voted = True
                        print "you voted"

                # action if he voted or not
                if voted is False:

                    cc = Choice(date_vote=dater, time_vote=hrs, restaurant_vote_id=ratio, person_id=checking_email.id)
                    cc.save()
                    address = "thank/?email="+your_email+"/"
                    return HttpResponseRedirect(address)
                elif voted is True:
                    message = "you already voted tomorrow try again"
                    return render(request, "thanks.html", {"message": message})

                address = "thank/?email="+your_email+"/"
                return HttpResponseRedirect(address)

            else: # if its after cut_hour
                message = "its after time, talk to your PA he might take your order"
                return render(request, "thanks.html", {"message": message})


    #regular empty forms render for the first time.
    else:
        form = polls.forms_DK.NameForm()
    django.setup()
    all_restaurants = Restaurant.objects.all()

    message = "select the restaurant of your choice before: " + str(cut_hour_12)
    return render(request, "vote_form.html", {"message": message, "all_restaurants": all_restaurants, "form": form})
class VoteTests(base.BaseTestCase):

    def setUp(self):
        super().setUp()

        self.request_factory = RequestFactory()

        self.question = self.create_question(question_text='Some question.', days=0)
        self.question.save()

        self.choice1 = Choice(
            question=self.question,
            choice_text='Choice 1',
            votes=0,
        )
        self.choice1.save()

        self.choice2 = Choice(
            question=self.question,
            choice_text='Choice 2',
            votes=0,
        )
        self.choice2.save()

    def test_vote_counts_with_client(self):
        url = reverse('polls:vote', args=(self.question.id,))
        # follow=True follows the redirect chain so response is the end page
        response = self.client.post(url, {'choice': self.choice2.id}, follow=True)

        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "<li>{} -- 0 votes</li>".format(self.choice1.choice_text))
        self.assertContains(response, "<li>{} -- 1 vote</li>".format(self.choice2.choice_text))

    def test_post_redirect_with_client(self):
        url = reverse('polls:vote', args=(self.question.id,))
        response = self.client.post(url, {'choice': self.choice2.id})

        self.assertEqual(response.status_code, 302)
        self.assertEqual(response['Location'], reverse('polls:results', args=(self.question.id,)))

    def test_logged_in_redirect(self):
        # This test is no different from test_post_redirect, but it
        # shows an example with logging in before calling `post`.
        password = '******'
        user = User(username='******')
        user.set_password(password)
        user.save()

        logged_in = self.client.login(username=user.username, password=password)
        self.assertTrue(logged_in)

        url = reverse('polls:vote', args=(self.question.id,))
        response = self.client.post(url, {'choice': self.choice2.id})

        self.assertEqual(response.status_code, 302)
        self.assertEqual(response['Location'], reverse('polls:results', args=(self.question.id,)))
예제 #16
0
 def test_unicode(self):
     """
     str(Choice) or unicode(Choice) should be the choice_text
     """
     poll = create_poll(question="Testing unicode", days=0)
     choice = Choice(poll=poll, choice_text="Testing is fun!")
     choice.save()
     self.assertEqual(str(choice), choice.choice_text)
     self.assertEqual(unicode(choice), choice.choice_text)
     self.assertEqual(str(choice), unicode(choice))
예제 #17
0
def test_add_choice_to_no_question():
    """
    Assert Integrity error if a choice is added
    to a question that does not exist
    """
    with pytest.raises(IntegrityError) as excinfo:
        choice = Choice(question_id=33, choice_text="Test choice", votes=23)
        choice.save()

    assert "FOREIGN KEY constraint failed" in str(excinfo)
예제 #18
0
    def test_form_renders_poll_choices_as_radio_inputs(self):
        # set up a poll with a couple of choices
        poll1 = Poll(question='6 times 7', pub_date=timezone.now())
        poll1.save()
        choice1 = Choice(poll=poll1, choice='42', votes=0)
        choice1.save()
        choice2 = Choice(poll=poll1, choice='The Ultimate Answer', votes=0)
        choice2.save()

        # set up another poll to make sure we only see the right choices
        poll2 = Poll(question='time', pub_date=timezone.now())
        poll2.save()
        choice3 = Choice(poll=poll2, choice='PM', votes=0)
        choice3.save()

        # build a voting form for poll1
        form = PollVoteForm(poll=poll1)

        # check it has a single field called 'vote', which has right choices:
        self.assertEquals(form.fields.keys(), ['vote'])

        # choices are tuples in the format (choice_number, choice_text):
        self.assertEquals(form.fields['vote'].choices, [
            (choice1.id, choice1.choice),
            (choice2.id, choice2.choice),
        ])

        # check it uses radio inputs to render
        self.assertIn('input type="radio"', form.as_p())
예제 #19
0
    def test_list_question_relation(self):
        q = Question(
            question_text="question_text_006", pub_date=timezone.now())
        q.save()
        c = Choice(question=q, choice_text="006_001")
        c.save()

        response = self.client.get(
            reverse("polls:choice-list"), **self.auth_headers)

        self.assertEqual(q.id, json.loads(response.content)[0]["question"])
예제 #20
0
def createdb():
	from django.utils import timezone
	from polls.models import Poll, Choice
	n = int(raw_input("Enter no. of items to create: "))
	for i in xrange(n):
		p = Poll(question="Question = {0}".format(i), pub_date = timezone.now())
		p.save()
		for i in xrange(4):
			cycle = ['a', 'b', 'c', 'd']
			c = Choice(poll = p, choice_text = cycle[i], votes = 0)
			c.save()
예제 #21
0
 def handle(self, *args, **options):
     for pc in data:
         p = Poll(**pc['poll'])
         p.save()
         self.stdout.write('saved Poll: {}'.format(p))
         for c in pc['choices']:
             c = Choice(**c)
             c.poll = p
             c.save()
             self.stdout.write('saved Choice: {}'.format(c), ending=',')
         self.stdout.write('')
     self.stdout.write('DONE')
예제 #22
0
 def handle(self, *args, **options):
     for pc in data:
         p = Poll(**pc['poll'])
         p.save()
         self.stdout.write('saved Poll: {}'.format(p))
         for c in pc['choices']:
             c = Choice(**c)
             c.poll = p
             c.save()
             self.stdout.write('saved Choice: {}'.format(c), ending=',')
         self.stdout.write('')
     self.stdout.write('DONE')
예제 #23
0
 def setUp(self):
     User.objects.create_user(username='******', password='******')
     self.client.login(username='******', password='******')
     self.question = create_question("1 or 2?", pub_date=-4, end_date=5)
     self.first_choice = Choice(id=1,
                                question=self.question,
                                choice_text="1")
     self.second_choice = Choice(id=2,
                                 question=self.question,
                                 choice_text="2")
     self.first_choice.save()
     self.second_choice.save()
    def test_creating_new_choice_and_saving_it_to_the_database(self):

        #creating a poll object
        poll = Question(question_text="What are my choices?", pub_date=timezone.now())
        poll.save()

        #creating a choice object
        choice = Choice(question=poll, choice_text="You have no choice", votes=0)
        choice.save()

        #searching in database
        all_choices_in_database = poll.choice_set.all()
        self.assertEquals(all_choices_in_database.count(), 1)
예제 #25
0
def test_add_choice_to_question():
    """
    Test if we can add a choice to a question safely
    """
    pub_date = timezone.now()
    question = Question(question_text="Test question", pub_date=pub_date)
    question.save()
    choice = Choice(question_id=question.id,
                    choice_text="Test choice",
                    votes=23)
    choice.save()
    assert choice.choice_text == "Test choice"
    assert choice.votes == 23
예제 #26
0
 def setUp(self):
     User.objects.create_user(username='******', password='******')
     self.client.login(username='******', password='******')
     self.question = create_question("What is your gender?",
                                     pub_date=-4,
                                     end_date=5)
     self.first_choice = Choice(id=1,
                                question=self.question,
                                choice_text="male")
     self.second_choice = Choice(id=2,
                                 question=self.question,
                                 choice_text="female")
     self.first_choice.save()
     self.second_choice.save()
예제 #27
0
 def setUp(self):
     super(TestPollSample,self).setUp()
     self.poll = Poll(
         question="What is your favorite number?",
         pub_date=datetime.now()
     )
     self.poll.save()
     for i in range(1, 4):
         choice = Choice(
             poll = self.poll,
             choice=str(i),
             votes=0
         )
         choice.save()        
    def test_view_can_handle_votes_via_POST(self):
        # set up a poll with choices
        poll1 = Poll(question='6 times 7', pub_date=timezone.now())
        poll1.save()
        choice1 = Choice(poll=poll1, choice='42', votes=1)
        choice1.save()
        choice2 = Choice(poll=poll1, choice='The Ultimate Answer', votes=3)
        choice2.save()

        # set up our POST data - keys and values are strings
        post_data = {'vote': str(choice2.id)}

        # make our request to the view
        poll_url = '/poll/%d/' % (poll1.id, )
        response = self.client.post(poll_url, data=post_data)

        # retrieve the updated choice from the database
        choice_in_db = Choice.objects.get(pk=choice2.id)

        # check it's votes have gone up by 1
        self.assertEquals(choice_in_db.votes, 4)

        # always redirect after a POST - even if, in this case, we go back
        # to the same page.
        self.assertRedirects(response, poll_url)
예제 #29
0
    def test_saving_and_retrieving_choices(self):

        choice = Choice()
        choice.choice_text = '1. Demi Moore 2. Julia Roberts'
        choice.votes = 1000
        choice.save()

        saved_choices = Choice.objects.all()
        self.assertEqual(saved_choices.count(), 1)
        saved_choice = saved_choices[0]
        self.assertIn('1. Demi Moore 2. Julia Roberts',
            repr(saved_choice),
        )
        self.assertEqual(saved_choice.choice_text, '1. Demi Moore 2. Julia Roberts')
        self.assertEqual(saved_choice.votes, 1000)
예제 #30
0
def create_poll(question, days, choice_text=CHOICE_TEXT):
    """
    Creates a poll with the given 'question' published the given number of
    'days' offset to now (negative for polls published in the past,
    positive for polls that have yet to be published).
    """
    now = timezone.now()
    result = Poll(question=question, pub_date=now + datetime.timedelta(days))
    result.save()

    if choice_text:
        choice = Choice(choice_text=choice_text, poll=result)
        choice.save()

    return result
예제 #31
0
def index(request):
    if request.method=='GET' :
        latest_poll_list = Poll.objects.all().order_by('-pub_date')[:5]
        return render_to_response('polls/index.html', {'latest_poll_list': latest_poll_list})
    elif request.method== 'POST' :
    	newPoll=Poll(question=request.POST["poll"])
    	newPoll.save()
    	
    for key in request.POST.keys():
      if key.startswith("choice"):
      choice=Choice(poll=newPoll, choice=request.POST[key], votes=0)
      choice.save()
      
    latest_poll_list = Poll.objects.all().order_by('-pub_date')[Poll.objects.count()-1]
	return HttpResponseRedirect('/')
예제 #32
0
def insert_record(request):
    left = request.POST['left']
    right = request.POST['right']
    choice = request.POST['choice']
    usetime = request.POST['usetime']
    userID = request.POST['userID']
    newChoice = Choice(use_time=usetime,
                       left_pic_id=left,
                       right_pic_id=right,
                       choice_num=choice,
                       user_id=userID)
    print("newChoice")
    print(newChoice)
    newChoice.save()
    return JsonResponse({'inserted': True})
예제 #33
0
파일: views.py 프로젝트: bsdt2013/bsdtdemo
def results(request, poll_key):
    try:
        p = Poll.get_by_id(int(poll_key))
        c = Choice.query(Choice.poll == p.key)
    except:
        raise Http404
    return render_to_response('polls/results.html', {'poll': p, 'choices': c})
예제 #34
0
파일: models.py 프로젝트: bevilla/Sevran2
def test():
    import os
    from django.conf import settings
    from polls.models import Choice
    from django.db.utils import IntegrityError
    from PIL import Image

    for filename in os.listdir(settings.MEDIA_ROOT):
        try:
            Image.open(settings.MEDIA_ROOT + filename)
        except:
            pass
        else:
            if not Choice.objects.filter(image=filename):
                choice = Choice(image=filename)
                choice.save()
예제 #35
0
def seed_polls(num_entries=10, choice_min=2, choice_max=5, overwrite=False):
    """
    Seeds num_entries poll with random users as owners
    Each poll will be seeded with # choices from choice_min to choice_max
    """
    if overwrite:
        print('Overwriting polls')
        Poll.objects.all().delete()
    users = list(User.objects.all())
    count = 0
    for _ in range(num_entries):
        p = Poll(owner=random.choice(users),
                 text=fake.paragraph(),
                 pub_date=datetime.datetime.now())
        p.save()
        num_choices = random.randrange(choice_min, choice_max + 1)
        for _ in range(num_choices):
            c = Choice(poll=p, choice_text=fake.sentence()).save()
        count += 1
        percent_complete = count / num_entries * 100
        print("Adding {} new Polls: {:.2f}%".format(num_entries,
                                                    percent_complete),
              end='\r',
              flush=True)
    print()
예제 #36
0
파일: views.py 프로젝트: GitBulk/polls-api
    def create_question(self, question_text, choice_texts):
        question = Question(question_text=question_text)
        question.save()

        for choice_text in choice_texts:
            Choice(question=question, choice_text=choice_text).save()

        return question
예제 #37
0
def objects():
    for ln in DATA.splitlines():
        if ln:
            a = ln.split('|')
            q = Question(question_text=a[0].strip())
            yield q
            for choice in a[1:]:
                yield Choice(choice_text=choice.strip(), question=q)
예제 #38
0
파일: demo.py 프로젝트: DarioGT/lino
def objects():
    for ln in DATA.splitlines():
        if ln:
            a = ln.split('|')
            p = Poll(question=a[0].strip())
            yield p
            for choice in a[1:]:
                yield Choice(choice=choice.strip(), poll=p)
예제 #39
0
 def test_replace_user_vote(self):  
     self.new_question = create_question(question_text='How are you', days=-5)
     self.first_choice = Choice(id = 1, question = self.new_question, choice_text = "I'm ok")
     self.second_choice = Choice(id = 2, question = self.new_question, choice_text = "I'm fine")
     self.first_choice.save()
     self.second_choice.save()
     self.client.login(username='******', password='******')
     response = self.client.post(reverse('polls:vote', args=(self.new_question.id,)), {'choice':self.first_choice.id})
     self.first_choice = self.new_question.choice_set.get(pk = self.first_choice.id)
     self.assertEqual(response.status_code, 302)
     self.assertEqual(self.first_choice.vote_set.all().count(), 1)
     response = self.client.post(reverse('polls:vote', args=(self.new_question.id,)), {'choice':self.second_choice.id})
     self.second_choice = self.new_question.choice_set.get(pk = self.second_choice.id)
     self.first_choice = self.new_question.choice_set.get(pk = self.first_choice.id)
     self.assertEqual(response.status_code, 302)
     self.assertEqual(self.second_choice.vote_set.all().count(), 1)
     self.assertEqual(self.first_choice.vote_set.all().count(), 0)
예제 #40
0
	def test_choice_can_calculate_its_own_percentage_of_votes(self):
		poll = Poll(question='who?', pub_date=timezone.now())
		poll.save()
		choice1 = Choice(poll=poll, choice='me', votes=2)
		choice1.save()
		choice2 = Choice(poll=poll, choice='you', votes=1)
		choice2.save()

		self.assertEquals(choice1.percentage(),100*2/3.0 )
		self.assertEquals(choice2.percentage(), 100*1/3.0)
예제 #41
0
    def test_creating_some_choices_for_a_poll(self):
        # start by creating a new Poll object
        poll = Poll()
        poll.question = "What's up?"
        poll.pub_date = timezone.now()
        poll.save()

        # now create a Choice object
        choice = Choice()

        # link it with our Poll
        choice.poll = poll

        # give it some text
        choice.choice = "doin' fine..."

        # and let's say it's had some votes
        choice.votes = 3

        # save it
        choice.save()

        # try retrieving it from the database, using the poll object's reverse
        # lookup
        poll_choices = poll.choice_set.all()
        self.assertEquals(poll_choices.count(), 1)

        # finally, check its attributes have been saved
        choice_from_db = poll_choices[0]
        self.assertEquals(choice_from_db, choice)
        self.assertEquals(choice_from_db.choice, "doin' fine...")
        self.assertEquals(choice_from_db.votes, 3)
예제 #42
0
def create(request):
   """Creates a new poll instance."""
   poll = Poll(
       question = request.POST['question'],
       pub_date = datetime.datetime.now()
   )
   poll.save()
   choice = Choice(poll=poll, choice= request.POST['choice1'], votes=0)
   choice.save()
   choice = Choice(poll=poll, choice= request.POST['choice2'], votes=0)
   choice.save()
   choice = Choice(poll=poll, choice= request.POST['choice3'], votes=0)
   choice.save()
   return HttpResponseRedirect('/polls/%s' % poll.id)
예제 #43
0
    def test_create_some_choices_for_a_poll(self):
        # Create new poll object
        poll = Poll()
        poll.question = "What's up?"
        poll.pub_date = timezone.now()
        poll.save()

        # Create Choice object
        choice = Choice()
        choice.poll = poll
        choice.choice = "doin' fine..."

        # Give it faux votes
        choice.votes = 3
        choice.save()

        # Try to retrieve from DB using poll's reverse lookup.
        poll_choices = poll.choice_set.all()
        self.assertEquals(poll_choices.count(), 1)

        # Finally, check attrbs have been saved
        choice_from_db = poll_choices[0]
        self.assertEqual(choice_from_db, choice)
        self.assertEqual(choice_from_db.choice, "doin' fine...")
        self.assertEqual(choice_from_db.votes, 3)
예제 #44
0
파일: views.py 프로젝트: bsdt2013/bsdtdemo
def detail(request, poll_key):
    try:
        p = Poll.get_by_id(int(poll_key))
        c = Choice.query(Choice.poll == p.key)
    except:
        raise Http404
    return render_to_response('polls/detail.html',
                            {'poll': p, 'choices': c},
                            context_instance=RequestContext(request))
예제 #45
0
파일: views.py 프로젝트: EzicMan/PollsApp
def save(request):
    qd = request.POST
    quest = ""
    if(qd['createNew'] == "false"):
        id = int(qd['qid'])
        quest = get_object_or_404(Question,pk=id)
        quest.question_text = qd['qt']
        quest.pub_date = datetime.strptime(qd['date'] + ' ' + qd['time'], '%Y-%m-%d %H:%M')
        quest.choice_set.all().delete()
    else:
        quest = Question(question_text=qd['qt'],pub_date=datetime.strptime(qd['date'] + ' ' + qd['time'], '%Y-%m-%d %H:%M'))
        quest.save()
    m = qd['arrayChoice'].split('\0,')
    m[len(m)-1] = m[len(m)-1][:-1]
    for el in m:
        c = Choice(choice_text=el,votes=0,question=quest)
        c.save()
    return redirect('detail',quest.id)
예제 #46
0
  def save(self):
    if not self.form.is_valid():
      return False
    
    self.reset_pdf_cache()

    data = self.form.cleaned_data
    slide_set = self.event.presentation.slide_set

    if slide_set == None:
      slide_set = SlideSet()
      slide_set.presentation = self.event.presentation
      slide_set.save()
      self.event.presentation.slide_set = slide_set

    slide = self.form.instance
    if data['slide_type'] == 'poll':
      # delete the old slide if it has been changed to a poll
      if slide.id != None:
        slide.delete()

      slide = Poll()
      slide.question = data['poll_question']

    slide.slide_set = slide_set
    slide.offset = data['offset']
    if data['image']:
      base_path = os.path.dirname(slide_upload_to(slide, data['image'].name))
      slide.image = self.upload_file(data['image'], upload_to = base_path)

    self.event.presentation.video = data['video']
    slide.save()
    self.event.presentation.save()

    # we need to save the poll choices here, after the poll is saved and has an id
    if data['slide_type'] == 'poll':
      for choice_text in data['poll_choices'].split('\n'):
        print '!!!! choice: %s' % choice_text
        choice = Choice()
        choice.choice = choice_text
        choice.poll = slide
        choice.save()

    return True
예제 #47
0
class VotingTests(TestCase):
    def setUp(self):
        User.objects.create_user(username='******', password='******')
        self.client.login(username='******', password='******')
        self.question = create_question("What is your gender?",
                                        pub_date=-4,
                                        end_date=5)
        self.first_choice = Choice(id=1,
                                   question=self.question,
                                   choice_text="male")
        self.second_choice = Choice(id=2,
                                    question=self.question,
                                    choice_text="female")
        self.first_choice.save()
        self.second_choice.save()

    def test_authenticated_user_can_replace_their_vote(self):
        '''test authenticated user can replace their vote in this polls period'''
        response = self.client.post(
            reverse('polls:vote', args=(self.question.id, )),
            {'choice': self.first_choice.id})
        self.first_choice = self.question.choice_set.get(
            pk=self.first_choice.id)
        self.assertEqual(self.first_choice.vote_set.all().count(), 1)
        response = self.client.post(
            reverse('polls:vote', args=(self.question.id, )),
            {'choice': self.second_choice.id})
        self.second_choice = self.question.choice_set.get(
            pk=self.second_choice.id)
        self.first_choice = self.question.choice_set.get(
            pk=self.first_choice.id)
        self.assertEqual(self.second_choice.vote_set.all().count(), 1)
        self.assertEqual(self.first_choice.vote_set.all().count(), 0)

    def test_previous_vote_show(self):
        '''test previos vote show on detail page'''
        response1 = self.client.get(
            reverse('polls:detail', args=(self.question.id, )))
        self.assertContains(response1, "None")
        self.client.post(reverse('polls:vote', args=(self.question.id, )),
                         {'choice': self.first_choice.id})
        response1 = self.client.get(
            reverse('polls:detail', args=(self.question.id, )))
        self.assertNotContains(response1, "None")
예제 #48
0
    def setup_poll1(self):
        poll = Poll(question='Which is better?', pub_date=timezone.now())
        poll.save()

        email_choice = Choice(question=poll, choice_text='Email sign-up')
        email_choice.save()

        external_choice = Choice(question=poll, choice_text='External sign-in')
        external_choice.save()

        return (poll, email_choice, external_choice)
예제 #49
0
    def test_vote_answer_type_MANY(self):
        Poll.objects.create(
            name='Test_MANY', question='question1',
            begin_date=timezone.now(),
            end_date=timezone.now()+timezone.timedelta(minutes=1),
            answer_type='MANY'
        )

        poll = Poll.objects.get(name='Test_MANY')
        poll.choice_set.add(Choice(choice_text='ans1', created=timezone.now()))
        poll.choice_set.add(Choice(choice_text='ans2', created=timezone.now()))
        poll.choice_set.add(Choice(choice_text='ans3', created=timezone.now()))

        choices = poll.get_ordered_choices()

        self._common_test_for_ONE_and_MANY(poll, choices)

        response = self.client.post(
            '/polls/%s/vote/' % poll.id,
            {
                'choice': [choices[1].id, choices[2].id],
            },
            follow=True
        )
        results = self._last_results
        results[1] += 1
        results[2] += 1

        self._check_results(choices, results)

        response = self.client.post(
            '/polls/%s/vote/' % poll.id,
            {
                'choice': [choices[1].id, choices[1].id,
                           choices[0].id],
            },
            follow=True
        )
        results = self._last_results
        results[1] += 1
        results[0] += 1

        self._check_results(choices, results)
예제 #50
0
def create_poll(request):
    current_user = get_current_user(request=request)
    if request.method == "POST":
        #Create poll
        new_poll = Poll()
        new_poll.pub_date = datetime.datetime.now()
        new_poll.question = request.POST["question"]
        new_poll.master = current_user
        new_poll.save()
        #Create answers
        answers = [request.POST["answer1"], request.POST["answer2"], request.POST["answer3"], request.POST["answer4"], request.POST["answer5"], request.POST["answer6"]]
        for answer in answers:
            if answer != "":
                new_choice = Choice()
                new_choice.poll = new_poll
                new_choice.choice_text = answer
                new_choice.save()

    return render(request, "add_poll.html", {"current_user": current_user})
예제 #51
0
def objects():
    p = Question(question_text="What is your preferred colour?")
    yield p
    yield Choice(choice_text="Blue", question=p)
    yield Choice(choice_text="Red", question=p)
    yield Choice(choice_text="Yellow", question=p)
    yield Choice(choice_text="other", question=p)

    p = Question(question_text="Do you like Django?")
    yield p
    yield Choice(choice_text="Yes", question=p)
    yield Choice(choice_text="No", question=p)
    yield Choice(choice_text="Not yet decided", question=p)

    p = Question(question_text="Do you like ExtJS?")
    yield p
    yield Choice(choice_text="Yes", question=p)
    yield Choice(choice_text="No", question=p)
    yield Choice(choice_text="Not yet decided", question=p)
예제 #52
0
 def form_valid(self, form):
     choices_list = []
     if isinstance(form.cleaned_data['choice'], Choice):
         choice = form.cleaned_data['choice']
         choice.votes.add(self.request.user)
         choices_list.append(choice)
     elif isinstance(form.cleaned_data['choice'], str):
         choice = Choice(question_id=self.kwargs['question_id'],
                         choice_text=form.cleaned_data['choice'])
         choice.save()
         choice.votes.add(self.request.user)
     else:
         for choice in form.cleaned_data['choice']:
             choice.votes.add(self.request.user)
             choices_list.append(choice)
     bulk_update(choices_list)
     return HttpResponseRedirect(
         reverse('polls:results',
                 args=(self.get_form_kwargs()['question_id'], )))
예제 #53
0
def vote(request, question_id):
    p = get_object_or_404(Question, pk=question_id)
    try:
        selected_choice = Choice()
        for choice in get_list_or_404(Choice, question=question_id):
            if choice.id == long(request.POST['choice']):
                selected_choice = choice
    except (KeyError, Choice.DoesNotExist):
        # Redisplay the question voting form.
        return render(request, 'polls/detail.html', {
            'question': p,
            'error_message': "You didn't select a choice.",
        })
    else:
        selected_choice.votes += 1
        selected_choice.save()
        # Always return an HttpResponseRedirect after successfully dealing
        # with POST data. This prevents data from being posted twice if a
        # user hits the Back button.
        return HttpResponseRedirect(reverse('polls:results', args=(p.id,)))
예제 #54
0
def add(request):
   """Adds a new poll to the polls.
   Might be used for mass insertion of polls.
   Is currently commented out in template,
   but fully functional if uncommented"""
   poll = Poll(
       question = request.POST['question'],
       pub_date = datetime.datetime.now()
   )
   poll.save()
   choice = Choice(poll=poll, choice= request.POST['choice1'], votes=0)
   choice.save()
   choice = Choice(poll=poll, choice= request.POST['choice2'], votes=0)
   choice.save()
   choice = Choice(poll=poll, choice= request.POST['choice3'], votes=0)
   choice.save()
   return HttpResponseRedirect('/polls/')
    def setUp(self):
        super().setUp()

        self.request_factory = RequestFactory()

        self.question = self.create_question(question_text='Some question.', days=0)
        self.question.save()

        self.choice1 = Choice(
            question=self.question,
            choice_text='Choice 1',
            votes=0,
        )
        self.choice1.save()

        self.choice2 = Choice(
            question=self.question,
            choice_text='Choice 2',
            votes=0,
        )
        self.choice2.save()
    def test_view_can_handle_votes_via_POST(self):
        # set up a poll with choices
        poll1 = Poll(question='6 times 7', pub_date=timezone.now())
        poll1.save()
        choice1 = Choice(poll=poll1, choice='42', votes=1)
        choice1.save()
        choice2 = Choice(poll=poll1, choice='The Ultimate Answer', votes=3)
        choice2.save()

        # set up our POST data - keys and values are strings
        post_data = {'vote': str(choice2.id)}

        # make our request to the view
        poll_url = '/poll/%d/' % (poll1.id,)
        response = self.client.post(poll_url, data=post_data)

        # retrieve the updated choice from the database
        choice_in_db = Choice.objects.get(pk=choice2.id)

        # check it's votes have gone up by 1
        self.assertEquals(choice_in_db.votes, 4)

        # always redirect after a POST - even if, in this case, we go back
        # to the same page.
        self.assertRedirects(response, poll_url)
예제 #57
0
    def test_creating_some_choices_for_a_poll(self):
        # start by creating a new Poll object
        poll = Poll()
        poll.question = "What's up?"
        poll.pub_date = timezone.now()
        poll.save()

        # now create a Choice object
        choice = Choice()

        # link it with our Poll
        choice.poll = poll

        # give it some text
        choice.choice = "doin' fine..."

        # and let's say it's had some votes
        choice.votes = 3

        # save it
        choice.save()

        # try retrieving it from the database, using the poll object's reverse
        # lookup
        poll_choices = poll.choice_set.all()
        self.assertEquals(poll_choices.count(), 1)

        # finally, check its attributes have been saved
        choice_from_db = poll_choices[0]
        self.assertEquals(choice_from_db, choice)
        self.assertEquals(choice_from_db.choice, "doin' fine...")
        self.assertEquals(choice_from_db.votes, 3)
예제 #58
0
파일: tests.py 프로젝트: dyon/TDDjango
    def test_creating_some_choices_for_a_poll(self):
        # Start by creating a new Poll object
        poll = Poll()
        poll.question = "What's up?"
        poll.pub_date = timezone.now()
        poll.save()

        # Now we create a Choice object
        choice = Choice()

        # Link it to our poll
        choice.poll = poll
        choice.choice = 'Doing fine...'
        choice.votes = 3
        choice.save()

        # Try retrieving from the database using the poll object's reverse lookup
        poll_choices = poll.choice_set.all()
        self.assertEquals(poll_choices.count(), 1)

        # Finally, check that its attributes have been saved
        choice_from_db = poll_choices[0]
        self.assertEquals(choice_from_db, choice)
        self.assertEquals(choice_from_db.choice, 'Doing fine...')
        self.assertEquals(choice_from_db.votes, 3)
    def test_view_shows_total_votes(self):
        # set up a poll with choices
        poll1 = Poll(question='6 times 7', pub_date=timezone.now())
        poll1.save()
        choice1 = Choice(poll=poll1, choice='42', votes=1)
        choice1.save()
        choice2 = Choice(poll=poll1, choice='The Ultimate Answer', votes=2)
        choice2.save()

        response = self.client.get('/poll/%d/' % (poll1.id, ))
        self.assertIn('3 votes', response.content)

        # also check we only pluralise "votes" if necessary. details!
        choice2.votes = 0
        choice2.save()
        response = self.client.get('/poll/%d/' % (poll1.id, ))
        self.assertIn('1 vote', response.content)
        self.assertNotIn('1 votes', response.content)