示例#1
0
    def post(self):
        import cgi
        pname = cgi.escape(self.request.get('pname'))
        plist = cgi.escape(self.request.get('fields'))
        poll = db.get(db.Key.from_path("Poll", pname))
        if poll:
            #Checks if exists
            self.response.out.write('<html><body>Poll:<pre>')
            self.response.out.write(cgi.escape(self.request.get('pname')))
            self.response.out.write(
                '</pre> wasn\' added: already exists <hr/>back to <a href="/admin/">admin</a></body></html>'
            )
            return

        if len(plist.split(',')) < 2:
            #Validates field list
            self.response.out.write('<html><body>Poll:<pre>')
            self.response.out.write(cgi.escape(self.request.get('pname')))
            self.response.out.write(
                '</pre> wasn\' added: not enough options <hr/>back to <a href="/admin/">admin</a></body></html>'
            )
            return

        poll = Poll(key_name=pname, name=pname, values=plist.split(','))
        poll.put()
        self.response.out.write('<html><body>Poll:<pre>')
        self.response.out.write(cgi.escape(self.request.get('pname')))
        self.response.out.write(
            '</pre> added successfully <hr/>back to <a href="/admin/">admin</a></body></html>'
        )
示例#2
0
 def test_was_published_recently_with_future_poll(self):
     """
     was_published_recently() should return False for polls whose
     pub_date is in the future
     """
     future_poll = Poll(pub_date=timezone.now()+datetime.timedelta(days=30))
     self.assertEqual(future_poll.was_published_recently(), False)
示例#3
0
def create_a_poll(request,survey_id):
    # create a poll in a survey 
    # get questions from input 
    # redirect to craetPollPage
    
    
    logging.debug(request.POST)
    question = request.POST['Question0']
    choice_list = request.POST.getlist('Field1')
    s = get_object_or_404(Survey,pk = survey_id)
    # check if user correct
    if not s.author == request.user.username:
        return 
    
    p = Poll(survey=s, question = question)
    p.save()
    # get choice from form input
    logging.debug(choice_list)
    for c in choice_list:
        if c:
            logging.debug(c)
            choice = Choice(poll= p,  choice = c, votes=0)
            choice.save()
    
     
    return HttpResponseRedirect('createPollPage')
示例#4
0
 def test_was_published_recently_with_old_poll(self):
     """
     was_published_recently() should return False for polls whose pub_date
     is older than 1 day
     """
     old_poll = Poll(pub_date=timezone.now() - datetime.timedelta(days=30))
     self.assertEqual(old_poll.was_published_recently(), False)
示例#5
0
 def test_was_published_recently_with_recent_poll(self):
     """
     was_published_recently() should return True for polls whose pub_date
     is within the last day
     """
     recent_poll = Poll(pub_date=timezone.now() - datetime.timedelta(hours=1))
     self.assertEqual(recent_poll.was_published_recently(), True)
示例#6
0
    def test_was_published_recently_with_old_poll(self):
        """
            was_published_recently() should return False for polls whose pub_date
            is older than 1 day
"""
        old_poll = Poll(pub_date=timezone.now() - datetime.timedelta(days=30))
        self.assertEqual(old_poll.was_published_recently(), False)
示例#7
0
    def test_was_published_recently_with_recent_poll(self):
        """
            was_published_recently() should return True for polls whose pub_date
            is within the last day
"""
        recent_poll = Poll(pub_date=timezone.now() -
                           datetime.timedelta(hours=1))
        self.assertEqual(recent_poll.was_published_recently(), True)
示例#8
0
 def test_was_published_recently_with_future_poll(self):
     """
     was_published_recently() should return False for polls whose
     pub_date is in the future
     """
     future_poll = Poll(pub_date=timezone.now() +
                        datetime.timedelta(days=30))
     self.assertEqual(future_poll.was_published_recently(), True)
示例#9
0
 def post(self):
     question = self.request.get('question')
     poll = Poll()
     poll.question = question
     if users.get_current_user():
         poll.author = users.get_current_user()
     poll.put()
     self.redirect('/')
示例#10
0
    def test_polls_page_shows_links_to_all_polls(self):
        #setup polls
        poll1 = Poll(question='6 times 7', pub_date=timezone.now())
        poll1.save()
        poll2 = Poll(question='How is your day', pub_date=timezone.now())
        poll2.save()

        #access polls view
        response = self.client.get(reverse('polls.views.show_all_pools'))
        #check if right template used
        self.assertTemplateUsed(response, 'all_polls.html')

        #check if polls transferred to template
        polls_in_context = response.context['polls']
        self.assertEquals(list(polls_in_context), [poll1, poll2])

        #check if polls displayed on the page
        self.assertIn(poll1.question, response.content)
        self.assertIn(poll2.question, response.content)

        #check if polls has links to individual poll
        self.assertIn(reverse('polls.views.poll', args=[poll1.id]),
                      response.content)
        self.assertIn(reverse('polls.views.poll', args=[poll2.id]),
                      response.content)
示例#11
0
文件: views.py 项目: yrjie/Rghoul
def createPoll(request):
    if not request.POST:
        folders = utils.getDateList()
        if utils.getNowH() >= utils.dinnerH:
            meal = "dinner"
        else:
            meal = "lunch"
        return render_to_response("createpoll.html", {
            "folders": folders,
            "meal": meal
        })
    codeLen = 8
    codeChars = string.ascii_uppercase + string.ascii_lowercase + string.digits
    code = ""
    while True:
        code = "".join(random.choice(codeChars) for _ in range(codeLen))
        if not Poll.objects.filter(code=code):
            break
    owner = utils.escapeHtml(request.POST["owner"])
    if not owner:
        owner = utils.getMaskedIp(request)
    title = utils.escapeHtml(request.POST["title"])
    if not title:
        title = "%s's poll" % owner
    open = "open" in request.POST
    p = Poll(owner=owner,
             title=title,
             open=open,
             parent=utils.getToday(),
             code=code,
             count=0)
    result = {}
    result["0_-1"] = []  # any
    result["9_-1"] = []  # 9 any
    result["22_-1"] = []  # 22 any
    lunch9, lunch22, dinner9, dinner22 = utils.getFileLists()
    if utils.getNowH() >= utils.dinnerH:
        dish9 = [int(x.split(".")[0]) for x in dinner9]
        dish22 = [int(x.split(".")[0]) for x in dinner22]
    else:
        dish9 = [int(x.split(".")[0]) for x in lunch9]
        dish22 = [int(x.split(".")[0]) for x in lunch22]
    for d in dish9:
        result["9_" + str(d)] = []
    for d in dish22:
        result["22_" + str(d)] = []
    p.result = json.dumps(result)
    p.save()
    return redirect("/poll/%s/" % code)
示例#12
0
文件: app.py 项目: Alge/smspoll
    def on_message(self, message):
        print("Message recieved: {}".format(message))

        data = {}
        try:
            data = json.loads(message)

        except:
            self.write_message(json.dumps({"error": "not valid json"}))

        if "subscribe_poll" in data.keys():
            poll = Poll.get_or_none(Poll.id == data["subscribe_poll"])
            if not poll:
                self.write_message(
                    json.dumps({
                        "result":
                        "error",
                        "message":
                        "unable to find poll with id: {}".format(
                            data["subscribe_poll"])
                    }))
            else:
                self.subscriptions.append(poll)
                if poll.id not in clients.keys():
                    clients[poll.id] = []
                clients[poll.id].append(self)
                r = {
                    'type': 'response',
                    'response': 'success',
                    'message': "subscribed to poll {}".format(poll.id)
                }
                self.write_message(json.dumps(r))
                send_update(poll, self)
        else:
            self.write_message(json.dumps({"error": "unknown command"}))
示例#13
0
 def post(self, year):
     poll = Poll.get(year)
     if not poll:
         self.response.out.write('No poll for ' + year + '.')
         return
     poll.flush()
     self.response.out.write('Flushed.')
示例#14
0
    async def create_poll(self, ctx, duration, *, title):
        """
        Allows a user to create a poll.
        """

        duration = await self.parse_time_as_delta(duration)

        if not duration:
            await ctx.send("Poll must have a valid duration "
                           "that is greater than zero")
            return

        end_date = ut.get_utc_time() + duration
        embed = await self.create_poll_embed(title, end_date, False)
        message = await ctx.send(embed=embed)

        # Adds control emojis
        for emoji in POLL_CONTROL_EMOJI:
            await message.add_reaction(emoji)

        # Deletes the original command message
        await ctx.message.delete()

        poll = Poll.create(title=title,
                           creator_id=ctx.author.id,
                           message_id=message.id,
                           channel_id=message.channel.id,
                           end_date=end_date)

        await self.update_response_counts(poll)
示例#15
0
def add(request):
    if not request.user.id:
        return redirect('/accounts/login?flag=1')



    if request.POST:
        poll = Poll(question=request.POST.get('question'))
        poll.save()
        for ch in request.POST.getlist('choice'):
            choice = Choice(poll=poll, choice=ch)
            choice.save()
        poll_list = Poll.objects.all()
        return render_to_response('index.html',dict(poll_list=poll_list, msg_success='Successfully submitted poll and choices'))
    else:
        return render(request,'add.html',{})
示例#16
0
    def get(self):
        user = users.get_current_user()

        if user:
            polls = Poll.all()
            self.response.write(render('index.html', {'polls': polls}))
        else:
            self.redirect(users.create_login_url(self.request.uri))
示例#17
0
    def get(self, key):
        user = users.get_current_user()

        if user:
            poll = Poll.get(key)
            self.response.write(poll.question)
        else:
            self.redirect(users.create_login_url(self.request.uri))
示例#18
0
def get_poll_article(request, article_id):
    logged_user = request.user
    article = Article.objects.get(id=article_id)
    polls = logged_user.poll_set.all()
    articles = []
    for poll in polls:
        articles.append(poll.article)

    if article in articles:
        url = urlparse.urljoin('/fire/', article_id)
        return redirect(url)
    else:
        article.poll_num += 1
        article.save()
        poll = Poll(user=logged_user, article=article)
        poll.save()
        data = {}
        return redirect('/fire/')
示例#19
0
 async def poll_daemon(self):
     """
     Task loop that update response counts
     and ends polls that need to be ended
     """
     ongoing_polls = Poll.where('ended', False).get()
     for poll in ongoing_polls:
         if ut.get_utc_time() >= poll.end_date:
             await self.end_poll(poll)
示例#20
0
def poll():
    sender = profiles_dict[request.json['user_id']]
    text = request.json['text']
    options = request.json['options']
    poll_id = str(len(all_polls))
    all_polls[poll_id] = Poll(poll_id, sender, text, options)

    slackbot.broadcast_poll(poll_id, text, options, user_list)
    return make_boolean_response()
示例#21
0
 def get(self, year):
     poll = Poll.get(year)
     if not poll:
         self.response.out.write('No poll for ' + year + '.')
         return
     unc = []
     for b in poll.ballots():
         unc.extend(Vote.gql('WHERE ballot = :1 AND release = :2', b, None))
     unc.sort(key=lambda v: v.artist.lower())
     self.render('admin.html', poll=poll, unc=unc)
示例#22
0
        async def query_getter(user):
            query = Poll.join('users', 'polls.creator_id', '=', 'users.id') \
                .where('users.guild_id', user.guild.id)

            if title:
                query = query.where('polls.title', 'like', f'%{title}%')

            if not ut.is_admin(user):
                query = query.where('users.id', user.id)

            return query
示例#23
0
文件: views.py 项目: yrjie/Rghoul
def createPoll(request):
    if not request.POST:
        folders = utils.getDateList()
        if utils.getNowH() >= utils.dinnerH:
            meal = "dinner"
        else:
            meal = "lunch"
        return render_to_response("createpoll.html", {"folders":folders, "meal":meal})
    codeLen = 8
    codeChars = string.ascii_uppercase+string.ascii_lowercase+string.digits
    code = ""
    while True:
        code = "".join(random.choice(codeChars) for _ in range(codeLen))
        if not Poll.objects.filter(code=code):
            break
    owner = utils.escapeHtml(request.POST["owner"])
    if not owner:
        owner = utils.getMaskedIp(request)
    title = utils.escapeHtml(request.POST["title"])
    if not title:
        title = "%s's poll" % owner
    open = "open" in request.POST
    p = Poll(owner=owner, title=title, open=open, parent=utils.getToday(), code=code, count=0)
    result = {}
    result["0_-1"] = []  # any
    result["9_-1"] = []  # 9 any
    result["22_-1"] = []  # 22 any
    lunch9, lunch22, dinner9, dinner22 = utils.getFileLists()
    if utils.getNowH() >= utils.dinnerH:
        dish9 = [int(x.split(".")[0]) for x in dinner9]
        dish22 = [int(x.split(".")[0]) for x in dinner22]
    else:
        dish9 = [int(x.split(".")[0]) for x in lunch9]
        dish22 = [int(x.split(".")[0]) for x in lunch22]
    for d in dish9:
        result["9_"+str(d)] = []
    for d in dish22:
        result["22_"+str(d)] = []
    p.result = json.dumps(result)
    p.save()
    return redirect("/poll/%s/" % code)
示例#24
0
    async def on_poll_react(self, payload):
        """
        Listens for reactions to poll messages
        """

        # Ignores if any bots reacts
        if payload.member.bot:
            return

        # Ignores react if the message doesn't correspond to a poll
        message_id = payload.message_id
        poll = Poll.where('message_id', message_id).first()
        if not poll:
            return

        channel = self.bot.get_channel(payload.channel_id)
        try:
            message = await channel.fetch_message(message_id)
        except discord.errors.NotFound:
            return

        user = payload.member
        emoji = payload.emoji
        if emoji.name == DELETE_POLL_EMOJI:
            deleted = await self.user_delete_poll(poll, message, user)
            if not deleted:
                await message.remove_reaction(emoji, user)
            return

        # New responses after the poll has ended are not accepted
        end_date = poll.end_date
        if ut.get_utc_time() >= end_date or poll.ended:
            try:
                await message.remove_reaction(emoji, user)
            except discord.errors.NotFound:
                pass
            return

        if emoji.name == ADD_CHOICE_EMOJI:
            await self.get_new_choice_from_user(poll, message, user)
        elif emoji.name == END_POLL_EMOJI:
            await self.user_end_poll(poll, message, user)
        else:
            choice = poll.choices().where('reaction', str(emoji)).first()
            await self.toggle_poll_response(choice, message, user)

        try:
            await message.remove_reaction(emoji, user)
        except discord.errors.NotFound:
            pass

        if emoji.name not in POLL_CONTROL_EMOJI:
            await self.update_response_counts(poll)
示例#25
0
    def get_poll(self, id: str) -> Poll:
        response = self.poll_table.get_item(Key={
            "id": id,
            "SK": "poll_info"
        })["Item"]

        return Poll(
            response["id"],
            datetime.fromisoformat(response["date"]),
            response["question"],
            response["result"],
            response.get("user"),
        )
示例#26
0
 def get(self, year, name):
     poll = Poll.get(year)
     if not poll:
         self.response.out.write('No poll results for ' + year + '.')
         return
     name = name or 'results'
     rendered = getattr(poll, name)
     if not rendered:
         rendered = self.getRendered(name + '.html', poll=poll,
                                     time=time.ctime())
         setattr(poll, name, rendered)
         poll.put()
     self.response.out.write(rendered)
示例#27
0
	def post(self):
		new_poll = Poll()
		new_poll.question = self.request.get('question')
		new_poll.total_votes = 0
		new_poll.choices = [ Choice(id=ndb.Key(Choice,c).urlsafe(), choice=c, votes=0) for c in self.request.POST.getall('choice') if c ]
		new_poll.put()
		url = '/poll/' + new_poll.key.urlsafe()
		self.response.write('<pre>@ <a href="' + url + '">' + url + '</a></pre>')
示例#28
0
class PollModelTestCase(Chai, TestCase):

    def setUp(self):
        super(PollModelTestCase, self).setUp()
        self.subject = Poll()
    
    def test_is_visable(self):
        now = datetime.datetime.now()

        dt = self.mock()
        mock_dt = self.mock(models, 'datetime')
        self.expect(mock_dt.now).returns(now)
        self.subject.publish_date = now
        assert self.subject.is_visable()
    
    def test_is_not_visable(self):
        now = datetime.datetime.now()

        dt = self.mock()
        mock_dt = self.mock(models, 'datetime')
        self.expect(mock_dt.now).returns(now)
        self.subject.publish_date =  now - datetime.timedelta(days=10)
        assert not self.subject.is_visable()
示例#29
0
    def get(self, pollname):
        logging.info("Editing poll: " + pollname)
        poll = Poll.get_by_name(pollname)
        poll.start_time = models.get_time_as_local(poll.start_time)
        logging.info("Got poll from datastore: %s " % (poll))
        template = jinj.get_template('poll_create.html')

        return template.render({
            'politicalparties': politicalparties.all(),
            'start_time': poll.start_time,
            'name': poll.name,
            'duration': poll.duration,
            'edit': True
        })
示例#30
0
def get_all_votes(event, context):
    """
    Get most recent polls from ddb
    """

    logger.info("get all polls")
    polls = db.get_all_polls()
    return {
        "statusCode": 200,
        "headers": {
            "content-type": "application/json"
        },
        "body": Poll.schema().dumps(polls, many=True),
    }
示例#31
0
    def get_all_polls(self) -> List[Poll]:
        response = self.poll_table.scan(IndexName=self.main_page_gsi)["Items"]
        polls = []

        for poll in response:
            poll = Poll(
                poll["id"],
                datetime.fromisoformat(poll["date"]),
                poll["question"],
                poll["result"],
            )
            polls.append(poll)

        return polls
示例#32
0
    def get(self, pollname):
        logging.info("Editing poll: "+pollname)
        poll = Poll.get_by_name(pollname)
        poll.start_time = models.get_time_as_local(poll.start_time)        
        logging.info("Got poll from datastore: %s " % (poll))
        template = jinj.get_template('poll_create.html')

        return template.render({
            'politicalparties': politicalparties.all(),
            'start_time': poll.start_time,
            'name': poll.name,
            'duration': poll.duration,
            'edit': True
            })
示例#33
0
def create_a_poll(request, survey_id):
    # create a poll in a survey
    # get questions from input
    # redirect to craetPollPage

    logging.debug(request.POST)
    question = request.POST['Question0']
    choice_list = request.POST.getlist('Field1')
    s = get_object_or_404(Survey, pk=survey_id)
    # check if user correct
    if not s.author == request.user.username:
        return

    p = Poll(survey=s, question=question)
    p.save()
    # get choice from form input
    logging.debug(choice_list)
    for c in choice_list:
        if c:
            logging.debug(c)
            choice = Choice(poll=p, choice=c, votes=0)
            choice.save()

    return HttpResponseRedirect('createPollPage')
示例#34
0
 def addVote(self, request, page):
     user = auth.get_user(request)
     film = Film.objects.get(id=page)
     if not user.is_anonymous:
         user = CustomUser.objects.get(user=user)
         if self.is_valid():
             poll = Poll()
             poll.user = user
             poll.film = film
             poll.mark = self.cleaned_data.get("vote")
             poll.save()
             return False
         else:
             mistake = u"Форма заполнена с ошибками"
             return mistake
示例#35
0
def newpoll():
    if 'username' not in session:
        return redirect(url_for('routes.login'))
    form = NewPollForm()
    if request.method == 'POST':
        if form.validate() == False:
            return render_template('newpoll.html.j2', form=form)
        else:
            options = map(options_dict, form.options.data.split(','))
            user_id = session['uid']
            newpoll = Poll(form.name.data, json.dumps(options), user_id)
            db.session.add(newpoll)
            db.session.commit()
            flash('Poll added.')
            return redirect(url_for('routes.newpoll'))
    elif request.method == 'GET':
        return render_template('newpoll.html.j2', form=form)
示例#36
0
def generate():

    # get password, questino and options from POST data
    question = request.form.get("question")
    options = json.loads(request.form.get("options"))["options"]
    password = request.form.get("password")

    # generate entry and new url pid
    poll = Poll(question, options, password)
    db_session.add(poll)
    db_session.flush()
    db_session.commit()

    # return url pid
    resp = jsonify(pid=poll.pid)
    resp.headers['Access-Control-Allow-Origin'] = '*'
    return resp
示例#37
0
    async def summon_poll(self, ctx, poll_id: int):
        """
        Allows a user to bring forward a poll in the conversation,
        for the benefit of longer-duration polls
        """

        poll = Poll.find(poll_id)
        if not poll:
            await ctx.send(f"Poll with ID {poll_id} could not found.")
            return

        if ctx.author.id != poll.creator_id and not ut.is_admin(ctx.author):
            await ctx.send("You don't have permission to summon that poll!")
            return

        old_channel = self.bot.get_channel(poll.channel_id)

        try:
            old_message = await old_channel.fetch_message(poll.message_id)
            await old_message.delete()
        except discord.errors.NotFound:
            pass

        embed = await self.create_poll_embed(poll.title, poll.end_date,
                                             poll.ended)
        new_message = await ctx.send(embed=embed)

        if not poll.ended:
            await new_message.add_reaction(ADD_CHOICE_EMOJI)

        await new_message.add_reaction(DELETE_POLL_EMOJI)

        if not poll.ended:
            await new_message.add_reaction(END_POLL_EMOJI)
            for choice in poll.choices:
                await new_message.add_reaction(choice.reaction)

        await ctx.message.delete()

        poll.message_id = new_message.id
        poll.channel_id = ctx.channel.id
        poll.save()

        await self.update_response_counts(poll)
示例#38
0
    def post(self, *args):
        logging.info(self.request.arguments())
        name = self.request.get('name')
        start_time = parse(self.request.get('start_time'))
        duration = int(self.request.get('duration'))
        logging.info(name)
        party = politicalparties.all_parties[self.request.get(
            'political_party')]

        poll = Poll(name=name, start_time=start_time, duration=duration)
        logging.info(poll.start_time)
        poll.start_time = poll.start_time.replace(
            tzinfo=gettz('Europe/London'))
        poll.save()

        poll.create_choice(party['id'], party['short_name'], party['colour'])
        self.redirect("/admin/poll/list")
示例#39
0
    def test_creating_a_new_poll_and_saving_it_to_the_database(self):
        poll = Poll()
        poll.question = "What's up?"
        poll.pub_date = timezone.now()

        poll.save()

        all_polls_from_db = Poll.objects.all()
        self.assertEquals(len(all_polls_from_db), 1)
        first_poll_from_db = all_polls_from_db[0]
        self.assertEquals(first_poll_from_db, poll)

        self.assertEquals(first_poll_from_db.question, "What's up?")
        self.assertEquals(first_poll_from_db.pub_date, poll.pub_date)
示例#40
0
文件: app.py 项目: Alge/smspoll
    def post(self):
        try:
            sms = {}
            sms["to"] = self.get_argument("to")
            sms["from"] = self.get_argument("from")
            sms["message"] = self.get_argument("message")
            poll = Poll.get_or_none(Poll.number == sms["to"])
            if not poll:
                self.write("No poll with that number")
            else:
                if poll.add_answer(sms["message"], sms["from"]):
                    self.write("Success")
                    update_all_pollclients(poll)
                else:
                    self.write("Failed to add answer")
        except Exception as e:
            print(e)
            self.write("Failed tot parse request")

        self.finish()
示例#41
0
 def get(self):
     user = users.get_current_user()
     if user:
         if users.is_current_user_admin():
             template_values = {}
             polls = Poll.gql("ORDER BY name DESC")
             template_values["polls"] = polls
             apoll = ActivePoll.get_or_insert("key", mkey="activepoll")
             try:
                 currentpoll = apoll.poll.name
             except AttributeError:
                 currentpoll = ""  #unable to retrieve current poll
             template_values["currentpoll"] = currentpoll.strip()
             import os
             path = os.path.join(os.path.dirname(__file__), 'admin.html')
             self.response.out.write(template.render(path, template_values))
         else:
             self.abort(403)
     else:
         self.redirect(users.create_login_url(self.request.uri))
示例#42
0
def create_poll(event, context):
    """
    Create a new voting poll

    Example message from frontend:
    {
        "question": "what is that?"
        "choice1": "cat"
        "choice2": "dog"
    }
    """
    logger.info("Creating a new poll")
    logger.info(event)
    body = json.loads(event["body"])
    authorizer = event["requestContext"]["authorizer"]["jwt"]

    poll = Poll(
        f"poll_{uuid.uuid4()}",
        datetime.now(),
        body["question"],
        Counter({
            body["choice1"]: 0,
            body["choice2"]: 0
        }),
        authorizer["claims"]["username"],
    )
    db.insert_poll(poll)

    msg = {
        "status": "success",
        "message": f"poll {poll.id} is created",
        "poll_id": poll.id,
    }

    return {
        "statusCode": 200,
        "headers": {
            "content-type": "application/json"
        },
        "body": json.dumps(msg),
    }
示例#43
0
    def post(self, *args):
        logging.info(self.request.arguments())
        name = self.request.get('name')
        start_time = parse(self.request.get('start_time'))
        duration = int(self.request.get('duration'))
        logging.info(name)
        party = politicalparties.all_parties[self.request.get('political_party')]

        poll = Poll(name=name, start_time=start_time, duration=duration)
        logging.info(poll.start_time)
        poll.start_time = poll.start_time.replace(tzinfo=gettz('Europe/London'))
        poll.save()

        poll.create_choice(party['id'], party['short_name'], party['colour'])
        self.redirect("/admin/poll/list")
示例#44
0
    def validate(self):
        user = users.get_current_user()
        self.logout = users.create_logout_url(self.request.uri)

        self.voter = Voter.gql('WHERE user = :1', user).get()
        if not self.voter:
            return 'invalid'

        self.years = Poll.openYears()
        if not self.years:
            return 'closed'
        defaultYear = max(self.years)
        self.year = int(self.request.get('year') or self.voter.year
                        or defaultYear)
        if self.year not in self.years:
            self.year = defaultYear
        if self.voter.year != self.year:
            self.voter.year = self.year
            self.voter.put()

        self.ballot = Ballot.gql('WHERE voter = :1 and year = :2',
                                 self.voter, self.year).get()
        return None
示例#45
0
"""

# Create a new database with our models!
# ./manage.py syncdb

"""
LEARNING THE BASICS OF THE ORM
"""

from polls.models import *
from django.utils import timezone

# Queryset with all Poll objects in the database
Poll.objects.all()

p = Poll(question="What up?", pub_date=timezone.now())
p.save()

# Let's see the id
p.id
# There's also an alias
p.pk
# if you override the primary key name which by default is id
# you can still access it by pk.


from django.utils import timezone
p = Poll(question="What up?", pub_date=timezone.now())

Poll(question="What's not?", pub_date=timezone.now()).save()
Poll(question="How's it going?", pub_date=timezone.now()).save()
示例#46
0
	def get(self):
		query = Poll.query().order(-Poll.date)
		polls = query.fetch()
		self.response.write(render('home.html', { 'latest_poll_list':polls }))
示例#47
0
 def post(self, year):
     Poll.get(year).rankReleases()
     # TO DO: status page (with auto-refresh?)
     self.redirect('')
示例#48
0
 def get(self):
     self.render('admindex.html', polls=Poll.gql('ORDER BY year DESC'))
示例#49
0
文件: app.py 项目: Alge/smspoll
 def get(self):
     polls = Poll.select()
     self.render("templates/create_poll.html", polls=polls)
示例#50
0
	def test_was_published_recently_recent_poll(self):
		recent_poll = Poll(pub_date=timezone.now() - datetime.timedelta(hours=10))
		self.assertEqual(recent_poll.was_published_recently(),True)
示例#51
0
文件: app.py 项目: Alge/smspoll
    def get(self, poll_id):
        poll = Poll.get_or_none(Poll.id == poll_id)
        if poll == None:
            raise tornado.web.HTTPError(404)

        self.render("templates/poll.html", poll=poll)
示例#52
0
 def test_was_published_recently_with_future_poll(self):
     future_poll = Poll(question='Future', pub_date=timezone.now() + datetime.timedelta(days=30))
     self.assertEqual(future_poll.was_published_recently(), False)
示例#53
0
 def test_was_published_recently_with_old_poll(self):
     old_poll = Poll(question='Old', pub_date=timezone.now() - datetime.timedelta(days=2))
     self.assertEqual(old_poll.was_published_recently(), False)
示例#54
0
 def test_was_published_recently_with_recent_poll(self):
     recent_poll = Poll(question='Recent', pub_date=timezone.now() - datetime.timedelta(hours=5))
     self.assertEqual(recent_poll.was_published_recently(), True)
示例#55
0
 def post(self):
     parsed_args = poll_parser.parse_args()
     poll = Poll(name=parsed_args['name'], options=parsed_args['options'])
     session.add(poll)
     session.commit()
     return poll, 201
示例#56
0
 def get(self):
     self.render('index.html', years=Poll.openYears(),
                 oldyears=range(1995, 2004))
示例#57
0
 def setUp(self):
     super(PollModelTestCase, self).setUp()
     self.subject = Poll()
示例#58
0
	def test_was_published_recently_future_poll(self):
		future_poll = Poll(pub_date=timezone.now() + datetime.timedelta(days=20))
		self.assertEqual(future_poll.was_published_recently(),False)