def test_blog_form_saving(self):
        form = BlogForm(FakePost({"title": "new blog"}))
        self.assertTrue(form.validate())

        blog = Blog()
        form.populate_obj(blog)
        self.assertEqual(blog.title, "new blog")

        # no new blogs were created
        self.assertEqual(Blog.select().count(), 2)

        # explicitly calling save will create the new blog
        blog.save()

        # make sure we created a new blog
        self.assertEqual(Blog.select().count(), 3)

        form = BlogForm(FakePost({"title": "a edited"}), obj=self.blog_a)
        self.assertTrue(form.validate())
        form.populate_obj(self.blog_a)

        self.assertEqual(self.blog_a.title, "a edited")
        self.blog_a.save()

        # make sure no new blogs were created
        self.assertEqual(Blog.select().count(), 3)

        # grab it from the database
        a = Blog.get(title="a edited")

    def test_null_form_saving(self):
        form = NullFieldsModelForm(FakePost({"c": ""}))
        self.assertTrue(form.validate())

        nfm = NullFieldsModel()
        form.populate_obj(nfm)
        self.assertEqual(nfm.c, None)

        # this is a bit odd, but since checkboxes do not send a value if they
        # are unchecked this will evaluate to false (and passing in an empty
        # string evalutes to true) since the wtforms booleanfield blindly coerces
        # to bool
        self.assertEqual(nfm.b, False)

        form = NullFieldsModelForm(FakePost({"c": "", "b": ""}))
        self.assertTrue(form.validate())

        nfm = NullFieldsModel()
        form.populate_obj(nfm)
        self.assertEqual(nfm.c, None)

        # again, this is for the purposes of documenting behavior -- nullable
        # booleanfields won't work without a custom field class
        # Passing an empty string will evalute to False
        # https://bitbucket.org/simplecodes/wtforms/commits/35c5f7182b7f0c62a4d4db7a1ec8719779b4b018
        self.assertEqual(nfm.b, False)

        form = NullFieldsModelForm(FakePost({"c": "test"}))
        self.assertTrue(form.validate())

        nfm = NullFieldsModel()
        form.populate_obj(nfm)
        self.assertEqual(nfm.c, "test")

 def test_validator_translation(self):
     form = self.F2(a='hellobye')
     self.assertFalse(form.validate())
     self.assertEqual(form.a.errors[0], 'field cannot be longer than 5 characters.')
     form = self.F(a='hellobye')
     self.assertFalse(form.validate())
     self.assertEqual(form.a.errors[0], 'Field cannot be longer than 5 characters.')

    def test_hidden_field_none(self):
        class TestNullEntryForm(WTForm):
            blog = HiddenQueryField(query=Blog.select())

        form = TestNullEntryForm(FakePost({"blog": ""}))

        # check the htmlz for the form's hidden field
        html = form._fields["blog"]()
        self.assertEqual(html, u'<input id="blog" name="blog" type="hidden" value="">')

        self.assertTrue(form.validate())
        self.assertEqual(form.blog.data, None)

        entry = NullEntry()
        form.populate_obj(entry)

        # ensure entry count hasn't changed
        self.assertEqual(NullEntry.select().count(), 0)

        entry.save()
        self.assertEqual(NullEntry.select().count(), 1)

        # make sure the blog object came through ok
        self.assertEqual(entry.blog, None)

        # edit entry a1
        form = TestNullEntryForm(FakePost({"blog": None}), obj=self.entry_a1)

        # check the htmlz for the form's hidden field
        html = form._fields["blog"]()
        self.assertEqual(html, u'<input id="blog" name="blog" type="hidden" value="">')

        self.assertTrue(form.validate())

    def test_hidden_field(self):
        class TestEntryForm(WTForm):
            blog = HiddenQueryField(query=Blog.select())
            title = wtfields.TextField()
            content = wtfields.TextAreaField()

        form = TestEntryForm(FakePost({"title": "new entry", "content": "some content", "blog": self.blog_b.get_id()}))

        # check the htmlz for the form's hidden field
        html = form._fields["blog"]()
        self.assertEqual(html, u'<input id="blog" name="blog" type="hidden" value="%s">' % self.blog_b.get_id())

        self.assertTrue(form.validate())
        self.assertEqual(form.blog.data, self.blog_b)

        entry = Entry()
        form.populate_obj(entry)

        # ensure entry count hasn't changed
        self.assertEqual(Entry.select().count(), 3)

        entry.save()
        self.assertEqual(Entry.select().count(), 4)
        self.assertEqual(self.blog_a.entry_set.count(), 2)
        self.assertEqual(self.blog_b.entry_set.count(), 2)

        # make sure the blog object came through ok
        self.assertEqual(entry.blog, self.blog_b)

        # edit entry a1
        form = TestEntryForm(
            FakePost({"title": "a1 edited", "content": "a1 content", "blog": self.blog_b.get_id()}), obj=self.entry_a1
        )

        # check the htmlz for the form's hidden field
        html = form._fields["blog"]()
        self.assertEqual(html, u'<input id="blog" name="blog" type="hidden" value="%s">' % self.blog_b.get_id())

        self.assertTrue(form.validate())

        form.populate_obj(self.entry_a1)
        self.entry_a1.save()

        self.assertEqual(self.entry_a1.blog, self.blog_b)

        self.assertEqual(self.blog_a.entry_set.count(), 1)
        self.assertEqual(self.blog_b.entry_set.count(), 3)

        # pull from the db just to be 100% sure
        a1 = Entry.get(title="a1 edited")

    def test_form(self):
        tcache = i18n_form.translations_cache
        tcache.clear()
        form = self.F()

        assert ('en_US', 'en') in tcache
        assert form._get_translations() is tcache[('en_US', 'en')]
        assert not form.validate()
        self.assertEqual(form.a.errors[0], 'This field is required.')

        form = self.F(LANGUAGES=['es'])
        assert ('es', ) in tcache
        self.assertEquals(len(tcache), 2)
        assert not form.validate()
        self.assertEqual(form.a.errors[0], 'Este campo es obligatorio.')

 def post(self):
     next_url = self.request.params.get('next_url', webapp2.uri_for('main'))
     form = MojangLoginForm(self.request.POST)
     if form.validate():
         username = form.username.data
         password = form.password.data
         try:
             u, uuid, access_token = mojang_authentication(username, password)
             if u:
                 email = None
                 if '@' in username:
                     email = username
                 auth_id = User.get_mojang_auth_id(uuid=uuid)
                 self.login_auth_id(auth_id, nickname=u, username=u, email=email)
                 self.redirect(next_url)
                 return
         except MojangException as me:
             message = u'Mojang authentication failed (Reason: {0}).'.format(me)
             self.session.add_flash(message, level='error')
     gae_login_uri = get_gae_login_uri(self, next_url)
     context = {
         'gae_login_uri': gae_login_uri,
         'mojang_login_form': form,
         'next_url': next_url
     }
     self.render_template('login.html', context=context)

 def post(self):
     next_url = self.request.params.get('next_url', webapp2.uri_for('user_profile'))
     form = UsernameClaimForm(self.request.POST)
     if form.validate():
         username = form.username.data
         password = form.password.data
         try:
             u, uuid, access_token = mojang_authentication(username, password)
             if u:
                 user = self.request.user
                 auth_id = User.get_mojang_auth_id(uuid=uuid)
                 existing_user = self.auth.store.user_model.get_by_auth_id(auth_id)
                 if existing_user is not None and user.key != existing_user.key:
                     user.merge(existing_user)
                 existing_user = User.lookup(username=u)
                 if existing_user is not None and user.key != existing_user.key:
                     user.merge(existing_user)
                 else:
                     user.add_username(u)
                     auth_id = User.get_mojang_auth_id(uuid=uuid)
                     user.add_auth_id(auth_id)
                     user.put()
         except MojangException as me:
             message = u'Mojang authentication failed (Reason: {0}).'.format(me)
             logging.error(message)
             self.session.add_flash(message, level='error')
     self.redirect(next_url)

    def update(self):
        if request.is_xhr:
            status = "NOK"
            ret_id = 0
            if admin_per.require().can():
                form = MenuViewForm(request.form)

                myChoices = [('0', '...')] + [(str(page.id), page.translations[get_locale()].title) for page in
                                              Pages.query.order_by(Pages.updated_on.desc()).all()]
                form.page_view.choices = myChoices

                if form.validate():
                    res = update_node(request.form['node_id'], request.form['page_view'])
                    if res is not None:
                        ret_id = request.form['node_id']
                        status = "OK"
                else:
                    data = []
                    for field, errors in form.errors.items():
                        for error in errors:
                            data.append((getattr(form, field).label.text, error))

                    status = data
            return jsonify({'status': status, 'id': ret_id})

        else:
            # redirect to home
            return redirect(url_for('.index'))

 def post(self, key):
     try:
         server_key = ndb.Key(urlsafe=key)
         server = server_key.get()
         if server is None:
             self.abort(404)
         if not server.is_gce:
             self.redirect(webapp2.uri_for('home', server_key=server.url_key))
         form = ServerRestoreForm(
             formdata=self.request.POST,
             versions=gcs.get_versions(server.key.urlsafe()),
             timezone=self.request.user.timezone
         )
         if form.validate():
             gcs.restore_generation(server.key.urlsafe(), form.generation.data)
             name = None
             for choice in form.generation.choices:
                 if choice[0] == form.generation.data:
                     name = choice[1]
                     break
             message = u"Saved game restored."
             if name:
                 message = u"Saved game {0} restored.".format(name)
             logging.info(message)
             self.session.add_flash(message, level='info')
             time.sleep(1)
             self.redirect(webapp2.uri_for('home', server_key=server.url_key))
     except Exception, e:
         message = "Problem restoring game: {0}".format(e)
         logging.error(message)
         self.session.add_flash(message, level='error')

    def register_view(self):
        form = RegistrationForm(request.form)
        if request.method == 'POST' and form.validate():
            user = Users()

            user.username = form.username.data
            user.email = form.email.data
            user.roles = ','.join(form.role.data)
            # we hash the users password to avoid saving it as plaintext in the db,
            # remove to use plain text:
            user.password = generate_password_hash(form.password.data)

            Session.add(user)
            Session.commit()

            login.login_user(user)
            flash('Thanks for registering')
            return redirect(url_for('.index'))
        link = '<p>Already have an account? <a href="' + url_for('.login_view') + '">Click here to log in.</a></p>'
        form_roles = []
        roles = Session.query(Role).all()
        for role in roles:
            form_roles.append((role.key, role.name))
        form.role.choices = form_roles
        self._template_args['form'] = form
        self._template_args['link'] = link
        return super(MyAdminIndexView, self).index()

 def _common_test(self, expected_error, form_kwargs, form_class=None):
     if not form_class:
         form_class = self.F
     form = form_class(**form_kwargs)
     assert not form.validate()
     self.assertEqual(form.a.errors[0], expected_error)
     return form

 def edit_view(self):
     if (not request.args) or (not request.args.get('id')):
         return abort(404)
     id = request.args['id']
     procurement = models.Procurement.query.get(id)
     form = forms.ProcurementForm(request.form, procurement)
     # check that the user has permission
     if not g.user.is_admin:
         if procurement.country_id != g.user.country_id:
             return abort(401)
     # set dynamic select choices
     form.supplier.choices = forms.get_supplier_choices()
     form.product.choices = forms.get_product_choices()
     form.source.choices = forms.get_source_choices()
     if request.form:
         # update procurement details
         if request.method == 'POST' and form.validate():
             procurement = self.populate_procurement_from_form(procurement, form)
             db.session.add(procurement)
             db.session.commit()
             flash("The details were updated successfully.", "success")
             if request.args.get('host_url'):
                 target = get_redirect_target(param_name="host_url")
                 return redirect(HOST + target)
             return redirect(url_for('.index_view'))
     else:
         # set field values that weren't picked up automatically
         form.product.process_data(procurement.product_id)
         form.country.process_data(procurement.country_id)
         form.currency.process_data(procurement.currency_id)
         form.incoterm.process_data(procurement.incoterm_id)
         form.supplier.process_data(procurement.supplier_id)
         form.source.process_data(procurement.source_id)
     return self.render('admin/procurement.html', procurement=procurement, form=form, title="Edit procurement record", API_HOST=API_HOST)

def login_view():
    form = LoginForm(request.form)
    if request.method == "POST" and form.validate():
        user = form.get_user()
        login.login_user(user)
        return redirect(url_for("index"))

    return render_template("form.html", form=form)

def login_view():
  form = LoginForm(request.form)
  if request.method == 'POST' and form.validate():
    user = form.get_user()
    login.login_user(user)
    return redirect(url_for('index'))

  return render_template('form.html', form=form)

def register():
    form = RegistrationForm(request.form)
    #si el usuario esta registrado guardamos los datos
    if request.method == 'POST' and form.validate() and ('username' in session):
            #guardamos los datos nuevos o editados
            form.databasesMongoUpdate(conn,session['username'])
            #por si cambia el nombre de usuario
            session['username']=form.username.data
            #conn.insertData(form)
            return render_template('perfil.html',usuario=form.username.data,form=form)
    elif request.method == 'POST' and form.validate():
            #grabamos los datos
                form.databasesMongo(conn)
                return render_template('hijo.html',usuario=form.username.data)

    #devolvemos la pagina de registro
    return render_template('register.html',form=form)

def login():
    form = LoginForm(request.form)
    if request.method == 'POST' and form.validate():
        # login and validate the user...
        user = form.get_user()
        login_user(user)
        flash("Logged in successfully.")
        return redirect(url_for("search"))
    return render_template("login.html", form=form)

def profile(context, request):
    form = ProfileForm(request.POST)

    if request.method == 'POST' and form.validate():
        profile = request.user.profile = form.profile.data
        rev = UserProfileRevision(user=request.user, updated_by=request.user,
                                  content=profile)
        model.session.add(rev)

    return {}

def contact():
    form = ContactForm()
    if request.method == "POST":
        if form.validate() == False:
            flash("All fields are required.")
            return render_template("contact.html", form=form)
        else:
            return "Form posted."

    elif request.method == "GET":
        return render_template("contact.html", form=form)

def loginaction() :
	# handle user login
	form = LoginForm(request.form)
	if request.method == 'POST' and form.validate() :
	    user = form.get_user()
	    if login.login_user(user) :
	        session['user'] = user.login
	        print("User %s logged in successfully."%user.login)
	        return redirect(request.args.get('next') or url_for('vendor_page.index'))
	        
	return render_template('login.html', form=form)