class SearchView(BaseView): def __init__(self, request): BaseView.__init__(self, request) self.form = Form(self.request, schema=SearchFormAsin()) @view_config(route_name='search_form', renderer='templates/results.mako') def finder(self): items = [] if self.request.POST: data = self._validate_input() query_params, can_be_executed = query_preparator.prepare_params(data) if can_be_executed: items = item_getter.execute_query(query_params) else: self.request.session.flash('Please provide less than 5 asins') return dict(form=FormRenderer(self.form), items=items) def _validate_input(self): self.form.validate() if self.form.errors: self.request.session.flash('Please provide asins') return self.form.data
def concept_save_view(request): if "concept" in request.POST: form = Form(request, schema=ConceptAnswersSchema()) if form.validate(): answers = [] concept_answers = form.bind(models.ConceptAnswer()) concept = concept_answers.concept concept_answers = concept_answers.concept_answer for concept_answer in concept_answers: answer = models.ConceptAnswer() answer.concept = concept answer.concept_answer = concept_answer answers.append(answer) with transaction.manager: models.DBSession.add_all(answers) else: print form.all_errors() print "NOT VALIDATED" return "I saw it" form = Form(request, schema=ConceptSchema()) concept_model = None if form.validate(): concept = form.bind(models.Concept()) #with transaction.manager: # models.DBSession.add(concept) concept_model = models.DBSession.merge(concept) models.DBSession.flush() return HTTPFound(request.route_url("concept_edit_page", page="Concepts",\ concept_id=concept_model.id)) else: print "Failed"
def license_create(request): viewer_username = authenticated_userid(request) if viewer_username == "": viewer_username = "******" # form = Form(request, LicenseSchema) form = Form(request) if 'form.submitted' in request.POST and not form.validate(): # form didn't validate request.session.flash('form does not validate!') request.session.flash(form.data['license_name']) request.session.flash(form.data['license_url']) if 'form.submitted' in request.POST and form.validate(): request.session.flash('form validated!') license_name = form.data['license_name'] license = License( license_name=form.data['license_name'], license_album=form.data['license_album'], license_url=form.data['license_url'], ) dbsession.add(license) request.session.flash(u'writing to database ...') # ToDo: https://redmine.local/issues/5 return { 'viewer_username': viewer_username, 'form': FormRenderer(form) }
def band_add(request): form = Form(request, BandSchema) if 'form.submitted' in request.POST and not form.validate(): # form didn't validate request.session.flash('form does not validate!') if 'form.submitted' in request.POST and form.validate(): request.session.flash('form validated!') dbsession = DBSession() band_registrar = request.user if 'registrar_is_member' in form.data: request.session.flash( "reg_is_member: " + form.data['registrar_is_member']) band = Band( name=form.data['band_name'], homepage=form.data['band_homepage'], email=form.data['band_email'], registrar=request.user.username, registrar_id=request.user.id, ) dbsession.add(band) dbsession.flush() return HTTPFound(route_url('band_view', request, band_id=band.id)) return { 'viewer_username': authenticated_userid(request), 'form': FormRenderer(form) }
def test_is_validated_with_specified_params(self): from pyramid_simpleform import Form request = testing.DummyRequest() request.method = "POST" form = Form(request, SimpleFESchema) form.validate(params={'name' : 'foo'}) obj = form.bind(SimpleObj()) self.assert_(obj.name == 'foo')
def manage(self): errors = None if self.request.method == 'POST': sid = self.request.params.get('sid', None) else: sid = self.request.matchdict.get('sid', None) try: if sid: #edit model = supplierService.GetSupplier(sid, self.TenantId) if not model: return HTTPFound(location='/suppliers/index') form = Form(self.request, schema=SupplierSchema, obj=model) cntform = vForm(prefix='suppliercontact-', request=self.request, schema=ContactSchema, obj=model.Contacts[0]) valid = form.validate() valid = cntform.validate() and valid if valid: form.bind(model) cntform.bind(model.Contacts[0]) model.UpdatedBy = self.UserId model.Status = True if supplierService.SaveSupplier(model): return HTTPFound(location='/suppliers/index') else: errors = 'Unable to add suppliers details!' else: #add model = Supplier() form = Form(self.request, schema=SupplierSchema, defaults={}) cntform = vForm(prefix='suppliercontact-', request=self.request, schema=ContactSchema, defaults={}) valid = form.validate() valid = cntform.validate() and valid if valid: model = form.bind(Supplier()) contact = cntform.bind(SupplierContactDetails()) model.Contacts.append(contact) model.TenantId = self.TenantId model.CreatedBy = self.UserId model.Status = True if supplierService.AddSupplier(model): return HTTPFound(location='/suppliers/index') else: errors = 'Unable to save suppliers details!' except Exception, e: errors = str(e)
def test_bind_with_include(self): from pyramid_simpleform import Form request = testing.DummyRequest() request.method = "POST" request.POST['name'] = 'test' form = Form(request, SimpleFESchema) form.validate() obj = form.bind(SimpleObj(), include=['foo']) self.assert_(obj.name == None)
def test_bind(self): from pyramid_simpleform import Form request = testing.DummyRequest() request.method = "POST" request.POST["name"] = "test" form = Form(request, SimpleFESchema) form.validate() obj = form.bind(SimpleObj()) self.assert_(obj.name == "test")
def test_bind_with_exclude(self): from pyramid_simpleform import Form request = testing.DummyRequest() request.method = "POST" request.POST["name"] = "test" form = Form(request, SimpleFESchema) form.validate() obj = form.bind(SimpleObj(), exclude=["name"]) self.assertTrue(obj.name == None)
def managepurchase(self): errors = None model = None form = None productmodel = Product() pForm = Form(self.request, schema=ProductSchema, defaults=productmodel.toDict()) log.info(self.request.method) if self.request.method == 'GET': pid = self.request.matchdict.get('pid', None) else: pid = self.request.params.get('pid', None) lstSuppliers = self.GetSuppliers() try: if pid: model = stockService.GetPurchase(pid, self.TenantId) if not model: return HTTPFound(location='/stock/purchases') form = Form(self.request, schema=PurchaseSchema, obj=model) if form.validate(): form.bind(model) model.TenantId = self.TenantId model.UpdatedBy = self.UserId model.Status = True if stockService.SavePurchase(model): return HTTPFound(location=self.request.route_url('purchases')) else: errors = 'Unable to save purchase details!' else: model = Purchase() form = Form(self.request, schema=PurchaseSchema, defaults=model.toDict()) if form.validate(): model = form.bind(Purchase()) model.TenantId = self.TenantId model.CreatedBy = self.UserId model.Status = True if stockService.AddPurchase(model): return HTTPFound(location=self.request.route_url('editpurchase',pid=model.Id)) else: errors = 'Unable to save purchase details!' except Exception, e: errors = str(e) log.debug(e) DBSession.rollback()
def test_errorlist_with_field(self): from pyramid_simpleform import Form from pyramid_simpleform.renderers import FormRenderer request = testing.DummyRequest() request.method = "POST" form = Form(request, SimpleFESchema) form.validate() renderer = FormRenderer(form) self.assertEqual(renderer.errorlist("name"), '<ul class="error"><li>Missing value</li></ul>')
def band_edit(request): band_id = request.matchdict['band_id'] band = Band.get_by_band_id(band_id) if not isinstance(band, Band): msg = "Band id not found in database" # TODO: check template! return HTTPFound(route_url('not_found', request)) # no change through form, so reuse old value (for now) band_registrar = band.registrar band_registrar_id = band.registrar_id form = Form(request, schema=BandEditSchema, obj=band) if 'form.submitted' in request.POST and not form.validate(): # form didn't validate request.session.flash('form does not validate!') #request.session.flash(form.data['name']) #request.session.flash(form.data['homepage']) #request.session.flash(form.data['email']) if 'form.submitted' in request.POST and form.validate(): if form.data['name'] != band.name: band.name = form.data['name'] if DEBUG: # pragma: no cover print "changing band name" request.session.flash('changing band name') if form.data['homepage'] != band.homepage: band.homepage = form.data['homepage'] if DEBUG: # pragma: no cover print "changing band homepage" request.session.flash('changing band homepage') if form.data['email'] != band.email: band.email = form.data['email'] if DEBUG: # pragma: no cover print "changing band email" request.session.flash('changing band email') # TODO: trigger email_verification process #request.session.flash(u'writing to database ...') dbsession.flush() # if all went well, redirect to band view return HTTPFound(route_url('band_view', request, band_id=band.id)) return { 'viewer_username': authenticated_userid(request), 'form': FormRenderer(form) }
def manage(self): errors = None if self.request.method == 'POST': cid = self.request.params.get('cid', None) else: cid = self.request.matchdict.get('cid', None) try: if cid: model = customerService.GetCustomer(cid, self.TenantId) if not model: return HTTPFound(location='/customers/index') form = Form(self.request, schema=CustomerSchema, obj=model) cntform = Form(self.request, schema=ContactSchema, obj=model.Contacts[0]) if form.validate() and cntform.validate(): form.bind(model) cntform.bind(model.Contacts[0]) model.UpdatedBy = self.UserId model.Status = True if customerService.SaveCustomer(model): return HTTPFound(location='/customers/index') else: errors = 'Unable to add customer details!' else: model = Customer() form = Form(self.request, schema=CustomerSchema, defaults={}) cntform = Form(self.request, schema=ContactSchema, defaults={}) if form.validate() and cntform.validate(): model = form.bind(Customer()) contact = cntform.bind(CustomerContactDetails()) model.Contacts.append(contact) model.TenantId = self.TenantId model.CreatedBy = self.UserId model.Status = True log.info('adding new customer') if customerService.AddCustomer(model): return HTTPFound(location='/customers/index') else: errors = 'Unable to save customer details!' except Exception, e: errors = str(e)
def test_errorlist_with_no_errors(self): from pyramid_simpleform import Form from pyramid_simpleform.renderers import FormRenderer request = testing.DummyRequest() request.method = "POST" request.POST['name'] = 'test' form = Form(request, SimpleFESchema) form.validate() renderer = FormRenderer(form) self.assert_(renderer.errorlist() == '')
def api_student_assignment_upload(request): conn=DBSession() validators=dict(fsfileid=formencode.validators.String(not_empty=True,min=16,messages=dict(empty=(u'文件不能为空' ))),\ title=formencode.validators.String(not_empty=True,messages=dict(empty=(u'标题不能为空'))),\ description=formencode.validators.String(not_empty=True,messages=dict(empty=(u'描述不能为空'))),\ uploadid=formencode.validators.Int(not_empty=False), assignmentid=formencode.validators.Int(not_empty=True)) form=Form(request,validators=validators,state=State(request=request)) student=conn.query(Student).filter(Student.userid==request.user.id).first() if form.validate(): try: assignment=conn.query(Assignment).filter(Assignment.id==form.data['assignmentid']).first() if form.data['uploadid'] and int(form.data['uploadid']): upload=conn.query(AssignmentUpload).filter(AssignmentUpload.id==int(form.data['uploadid'])).first() upload.title=form.data['title'] upload.fsfileid=form.data['fsfileid'] upload.description=form.data['description'] upload.updatetime=time.time() upload.studentid=student.id conn.flush() else: upload=AssignmentUpload() upload.assignmentid=form.data['assignmentid'] upload.title=form.data['title'] upload.fsfileid=form.data['fsfileid'] upload.createtime=time.time() upload.updatetime=time.time() upload.description=form.data['description'] upload.studentid=student.id conn.add(upload) conn.flush() return dict(return_url='/student/assignment/list') except Exception,e: log.debug(e) return dict(code=301,error=u'参数错误')
def __call__(self): if Permission.FILE & self.user.permissions != Permission.FILE: raise HTTPForbidden('You are not authorized to upload files.') self.breadcrumbs.add('Archives', self.request.route_url('archives')) self.breadcrumbs.add('Upload', self.request.route_url('archives_upload')) self.title = 'Upload File' form = Form(self.request, schema=FileSchema, defaults={'title': '', 'fileDate': '', 'description': ''}) if 'submit' in self.request.POST and form.validate(): token = self.request.POST.get('_csrf') if token is None or token != self.request.session.get_csrf_token(): raise HTTPForbidden('CSRF token is invalid or missing.') file = File(name=self._validated(FileSchema, form, 'title'), filename=self._validated(FileSchema, form, 'fileUpload').filename, description=self._validated(FileSchema, form, 'description'), submitTime=datetime.datetime.utcnow(), fileDate=form.data['fileDate'] or datetime.date.today(), ownerid=self.user.id, isDeleted=False) self.dbsession.add(file) self.dbsession.flush() here = os.path.dirname(__file__) thisFile = self._validated(FileSchema, form, 'fileUpload').file open(os.path.join(here, os.path.pardir, 'data', 'archive', str(file.id)), 'wb').write(\ thisFile.read()) return HTTPFound(location=self.request.route_url('archives_file', fileid=file.id)) return self.finalize({'form': form})
def api_mentor_assignment_add(request): conn=DBSession() validators=dict(fsfileid=formencode.validators.String(not_empty=True,min=16,messages=dict(empty=(u'文件不能为空' ))),\ title=formencode.validators.String(not_empty=True,messages=dict(empty=(u'标题不能为空'))),\ description=formencode.validators.String(not_empty=True,messages=dict(empty=(u'描述不能为空'))),\ duedate=formencode.validators.String(not_empty=True,messages=dict(empty=(u'截止时间不能为空'))), lessonid=formencode.validators.Int(not_empty=True), assignmentid=formencode.validators.Int(not_empty=False)) form=Form(request,validators=validators,state=State(request=request)) if form.validate(): try: lesson=conn.query(Lesson).filter(Lesson.id==form.data['lessonid'],Lesson.courseid.in_(\ conn.query(Course.id).filter(Course.mentorid.in_(\ conn.query(Mentor.id).filter(Mentor.userid==request.user.id))))).first() if form.data['assignmentid'] and int(form.data['assignmentid']): assignment=conn.query(Assignment).filter(Assignment.id==lesson.assignmentid).first() assignment.title=form.data['title'] assignment.fsfileid=form.data['fsfileid'] assignment.duedate=time.mktime(time.strptime(form.data['duedate'],'%Y-%m-%d')) assignment.description=form.data['description'] conn.flush() else: assignment=Assignment() assignment.title=form.data['title'] assignment.fsfileid=form.data['fsfileid'] assignment.duedate=time.mktime(time.strptime(form.data['duedate'],'%Y-%m-%d')) assignment.description=form.data['description'] conn.add(assignment) conn.flush() lesson.assignmentid=assignment.id conn.flush() return dict(return_url='/mentor/lesson/listbycourse?courseid='+str(lesson.courseid)) except Exception,e: log.debug(e) return dict(code=301,error=u'参数错误')
def password_edit_view(request): """ Render the change password form page. Seek the database for the user datas based on user_id used in the route. If the user did not exist then add an error flash message and redirect to the user list. If the user exist then render an empty password form. If the form is validated then change the user password in the database and add success flash message. If the form is not valid, then display again the form with validation errors. :param request: a ``pyramid.request`` object """ _ = request.translate user_id = request.matchdict['user_id'] user = AuthUser.get_by_id(user_id) if not user: request.session.flash(_(u"This user did not exist!"), 'error') return HTTPFound(location=request.route_path('tools.user_list')) form = Form(request, schema=UserPasswordForm, obj=user) if 'form_submitted' in request.params and form.validate(): form.bind(user) DBSession.add(user) request.session.flash(_(u"Password updated."), 'success') return HTTPFound(location=request.route_path('tools.user_list')) return dict(renderer=FormRenderer(form))
def view_blog_edit(self): form = Form(self.request, schema=BlogCreateSchema, state=State(request=self.request)) blogname = get_param(self.request, 'blogname', self.context.name) text = get_param(self.request, 'text', self.context.description) image_url = get_param(self.request, 'image_url', self.context.image_url) if form.validate(): self.context.name = blogname self.context.description = text self.context.image_url = image_url self.message = msg['saved'] cbs = [p for p in self.request.params.keys() if u'checkbox' in p] # check all the checkbox-parameters and # parse them for cb in cbs: item = self.request.params[cb] self.context.remove(item) self.message = msg['items_removed'] _dict = { 'form': FormRenderer(form), 'message': self.message, 'blogname': blogname, 'text': text, 'image_url': image_url } return dict(self.base_dict.items() + _dict.items())
def view_signup(self): """ Register view for new users that aren't signed up yet """ username = get_param(self.request, 'username') email = get_param(self.request, 'email') password = u'' # Create form by using schemas with validations form = Form(self.request, schema=SignUpSchema, state=State(request=self.request)) if form.validate(): username = self.request.params['username'] password = self.request.params['password'] email = self.request.params['email'] get_resource('users', self.request).add(username, password, email) get_resource('groups', self.request).add(username, group_names['member']) get_resource('groups', self.request).add(username, u'u:%s' % username) self.message = msg['succeed_add_user'] + " " + username _dict = { 'url': self.request.application_url + '/signup', 'username': username, 'email': email, 'password': password, 'form': FormRenderer(form), 'params': self.request.params, 'message': self.message } return dict(self.base_dict.items() + _dict.items())
def login(request): message = None form = Form(request, schema=UserSchema()) if request.method == 'POST' and form.validate(): username = request.params['username'] password = request.params['password'] password_again = request.params['password_again'] if bool(password_again): if password == password_again: user = form.bind(User()) DBSession.add(user) DBSession.flush() user_id = user.id headers = remember(request, user.id) return HTTPFound(location='/', headers=headers) else: message = 'Passwords do not match.' else: user = DBSession.query(User).filter(User.username==username).first() if user and user.password == password: headers = remember(request, user.id) return HTTPFound(location='/', headers=headers) else: message = 'Username or password is incorrect.' return { 'message': message, 'form': form, 'renderer': FormRenderer(form), 'user': get_user(request), }
def view_user_edit(self): """ View for editing a single user """ form = Form(self.request, schema=UserEditSchema, state=State(request=self.request)) self.error_message = None if form.validate(): password = self.request.params['password'] if self.context.validate_password(password): if self.request.params['new_password']: password = self.request.params['new_password'] self.message = 'Successfully saved' email = self.request.params['email'] self.context.edit(password, email) else: self.error_message = msg['password_invalid'] _dict = { 'username': self.context.username, 'form': FormRenderer(form), 'email': self.context.email, 'message': self.message, 'error_message': self.error_message } return dict(self.base_dict.items() + _dict.items())
def contact_view(request): form = Form(request, schema=ContactSchema) if form.validate(): mailer = request.registry['mailer'] office_email = request.registry.settings['office.email'] from_ = "%s <%s>" % (form.data['name'], form.data['email']) message = Message( subject=form.data['subject'] + ' [formative.co.za]', sender=form.data['email'], recipients=[office_email], body=form.data['message'], extra_headers = {"From": from_} ) mailer.send_immediately(message) request.session.flash('Message sent.', queue='info') return HTTPFound(location="/") if form.errors: request.session.flash('There are errors in your form.', queue='error') return {"renderer":FormRenderer(form)}
def motion_add(request): """create a new motion. 1. show new motion form 2. save to database after user submit """ # initialize the form to select all participants all_users = load_users() all_user_options = [(itm.id, itm.name) for itm in all_users] selected_users = [itm.id for itm in all_users] # add four blank options on new motion form form = Form(request, schema=MotionSchema, defaults=dict(participants = selected_users, options=["","","",""])) if form.validate(): title = form.data.get("title") desc = form.data.get("desc") options = form.data.get("options") users = form.data.get("participants") add_motion(title, desc, options, users) return HTTPFound(location=route_path('motion_list', request)) return dict(renderer=FormRenderer(form), all_user_options=all_user_options)
def user_add(request): form = Form(request, schema=RegistrationSchema) if "form.submitted" in request.POST and form.validate(): session = DBSession() username = form.data["username"] user = User(username=username, password=form.data["password"], name=form.data["name"], email=form.data["email"]) session.add(user) headers = remember(request, username) redirect_url = request.route_url("main") return HTTPFound(location=redirect_url, headers=headers) login_form = login_form_view(request) return { "form": FormRenderer(form), "toolbar": toolbar_view(request), "cloud": cloud_view(request), "latest": latest_view(request), "login_form": login_form, }
def edit(request): """customer edit """ id = request.matchdict['id'] dbsession = DBSession() customer = dbsession.query(Customer).filter_by(id=id).one() print customer address = dbsession.query(Address).filter_by(user_id=id).one() if customer is None or address is None: request.session.flash("error;Customer not found!") return HTTPFound(location=request.route_url("customer_list")) generalForm = Form(request, schema=CustomerForm, obj=customer) locationForm = Form(request, schema=LocationForm, obj=address) if "general_submitted" in request.POST and generalForm.validate(): generalForm.bind(customer) dbsession.add(customer) request.session.flash("success; Successful call to update customer") if "location_submitted" in request.POST: locationForm.bind(address) dbsession.add(address) request.session.flash("success; Successful call to update location") action_url = request.route_url("customer_edit", id=id) return dict(generalForm=FormRenderer(generalForm), locationForm=FormRenderer(locationForm), action_url=action_url)
def crime_add(self): """ Crimes list for classification :return: """ # Gera formulário form = Form( self.request, defaults={}, schema=crime_schema.CrimeSchema() ) if form.validate(): log.debug("Dados do formulário: ") # Tenta instanciar o formulário no objeto crime_obj = Crimes( category_name=form.data.get('category_name'), category_pretty_name=form.data.get('category_pretty_name'), description=form.data.get('description'), date=datetime.datetime.now(), default_token=form.data.get('default_token'), tokens=form.data.get('tokens'), color=form.data.get('color') ) # persist model somewhere... crime_obj.create_crimes() return HTTPFound(location="/crime") return dict( renderer=FormRenderer(form), action=self.request.route_url('crime_add') )
def view_task(request): story_id = request.matchdict['story_id'] story = DBSession.query(Story).get(story_id) task_id = request.matchdict['task_id'] task = DBSession.query(Task).get(task_id) times_spent = DBSession.query(TimeSpent.duration).filter( TimeSpent.task_id==task_id).all() form = Form(request, schema=TimeSpentSchema()) if request.method == 'POST' and form.validate(): time_spent = form.bind(TimeSpent()) time_spent.task_id = task_id time_spent.task = task DBSession.add(time_spent) DBSession.flush() return HTTPFound(location='/story/%s/task/%s' % (story_id, task_id)) return { 'story': story, 'story_id': story_id, 'task': task, 'task_id': task_id, 'times_spent': times_spent, 'renderer': FormRenderer(form), 'form': form, 'total_time_spent': str(sum_time_spent(times_spent)), 'user': get_user(request), }
def add_message(request): """ Add message receive an topic """ form = Form(request, schema=MessageSchema ) topic = request.matchdict['name'] if form.validate(): title = form.data['title'] author = form.data['author'] content = form.data['content'] topic_oid = topic slug = make_slug(title) d = { 'title' : title, 'author' : author, 'content':content, 'topic' : topic_oid, 'slug' : slug } request.db['Message'].insert(d) return HTTPFound(location='/topic/'+topic) return { 'form' : FormRenderer(form), 'topic' : topic }
def user_add(request): form = Form(request, schema=RegistrationSchema) if 'form.submitted' in request.POST and form.validate(): session = DBSession() username=form.data['username'] user = User( username=username, password=form.data['password'], name=form.data['name'], email=form.data['email'] ) session.add(user) headers = remember(request, username) redirect_url = route_url('main', request) return HTTPFound(location=redirect_url, headers=headers) login_form = login_form_view(request) return { 'form': FormRenderer(form), 'toolbar': toolbar_view(request), 'cloud': cloud_view(request), 'latest': latest_view(request), 'login_form': login_form, }
def addlga(request): title="Add Local Government Areas" state_id = request.matchdict['state_id'] state = State.get_by_id(state_id) form = Form(request, schema=StateSchema) if 'form_submitted' in request.POST and form.validate(): lga_string = form.data['name'] lga=LGA.create_lga(state_id,lga_string) request.session.flash("success; Lga added") return HTTPFound(location=request.route_url('view_state', state_id=state_id)) action_url = request.route_url('add_lga', state_id=state_id) return dict( title=title, state=state, form=FormRenderer(form), action_url=action_url)
def add_node(request): """Adds a new into Marteau""" check_auth(request) owner = request.user form = Form(request, schema=NodeSchema) if not form.validate(): request.session.flash("Bad node name") return HTTPFound(location='/nodes') node_name = form.data.get('name') node = Node(name=node_name, owner=owner) queue = request.registry['queue'] queue.save_node(node) return HTTPFound(location='/nodes')
def person_add_view(request): health_id = request.POST['health_id'] form = Form(request, schema=PersonSchema()) if form.validate(): person = form.bind(models.Person()) with transaction.manager: models.DBSession.add(person) return HTTPFound(request.route_url("patient_dashboard_page",\ health_id=health_id, page= "Patient Dashboard")) #page= "Patients List", health_id= health_id) else: print "Form Validation Failed" print form.all_errors() print request.POST return {"message": "Reched ME!!"}
def change_username(request): "Change username" form = Form(request, schema=schema.ChangeUsername) user = request.user if request.method == 'POST': if form.validate(): user.username = form.data['username'] model.save(user) request.registry.notify(events.UserChangedUsername(request, user)) # Get location based on new username location = get_redirect_location(request) return HTTPFound(location=location) # Get location based on unchanged username location = get_redirect_location(request) form.data['next'] = location return {'renderer': FormRenderer(form), 'user': user}
def user_edit(request): id = request.matchdict['id'] user = load_user(id) if not user: return HTTPUnauthorized() form = Form(request, schema=UserSchema, obj=user) if form.validate(): update_user(id, form.data.get("name"), form.data.get("email"), form.data.get("vote_weight")) return HTTPFound(location=route_path("user_list", request)) return dict(renderer=FormRenderer(form))
def register(self): form = Form(self.request, schema=UserSchema) if form.validate(): user = form.bind(resources.User()) user.password, user.salt = gen_hash_password(user.password) personal_tag = resources.Tag() personal_tag.label = user.email personal_tag.tag_type = 'user' personal_tag.tag_permission = 2 personal_tag.save() user.personal_tag = personal_tag user.save() user = authenticate_user(self.request.params['email'], self.request.params['password']) headers = remember(self.request, str(user.id)) return HTTPFound(location="/", headers=headers) return {'renderer': FormRenderer(form)}
def start_session(request): form = Form(request, schema=StartSessionForm()) if form.validate(): identifier = form.data["identifier"] secret = form.data["secret"] account_name = form.data["account_name"] db = request.db session = AuthSession.create(db, identifier, secret, account_name) if session is None: raise exc.HTTPForbidden() else: log.debug("new auth session for client %s username %s", identifier, account_name) return {"auth_token": session.token} else: raise exc.HTTPForbidden()
def signin(request): form = Form(request, schema=SigninSchema()) if form.validate(): query = DBSession.query(User).filter(User.email == form.data['email']) if query.count(): user = query.first() if user.check_password(form.data['password']): headers = remember(request, user.email) return HTTPFound(location='/', headers=headers) else: request.session.flash(u'Wrong email or password', 'error') else: request.session.flash(u'Wrong email or password', 'error') return _response_dict( request, renderer=FormRenderer(form), )
def editstate(request): state_id = request.matchdict['state_id'] state =State.get_by_id(state_id) title = "Editing %s" %(state.name) form = Form(request, schema=StateSchema) if 'form_submitted' in request.POST and form.validate(): s_string = form.data['name'] state.name = s_string transaction.commit() request.session.flash('success; State updated') return HTTPFound(location=request.route_url('list_state')) action_url = request.route_url('edit_state', state_id=state_id) return dict( title=title, form=FormRenderer(form), state=state, action_url=action_url)
def __call__(self): if self.user.permissions & Permission.NEWS != Permission.NEWS: raise HTTPForbidden( 'You are not authorized to edit this news article.') self.breadcrumbs.add('News', self.request.route_url('news')) try: article = self.dbsession.query(News).filter( News.id == self.request.matchdict['articleid']).one() except: raise HTTPNotFound('No article found.') if article.isDeleted: raise HTTPNotFound('No article found.') self.breadcrumbs.add( article.title, self.request.route_url('news_article', articleid=article.id)) self.breadcrumbs.add( 'Edit', self.request.route_url('news_edit', articleid=article.id)) self.title = 'Editing "' + article.title + '"' form = Form(self.request, schema=NewsSchema, defaults={ 'title': article.title, 'content': article.content }) if 'edit' in self.request.POST and form.validate(): token = self.request.POST.get('_csrf') if token is None or token != self.request.session.get_csrf_token(): raise HTTPForbidden('CSRF token is invalid or missing.') article.title = self._validated(NewsSchema, form, 'title') article.content = self._validated(NewsSchema, form, 'content') article.lastModified = datetime.datetime.utcnow() self.dbsession.add(article) self.dbsession.flush() return HTTPFound(location=self.request.route_url( 'news_article', articleid=article.id)) elif 'delete' in self.request.POST and 'deleteCheck' in self.request.POST: token = self.request.POST.get('_csrf') if token is None or token != self.request.session.get_csrf_token(): raise HTTPForbidden('CSRF token is invalid or missing.') article.isDeleted = True self.dbsession.add(article) self.dbsession.flush() return HTTPFound(location=self.request.route_url('news')) return self.finalize({'form': form, 'article': article})
def genkey(self): self.require_verification() form = Form(self.request, schema=forms.GenKeySchema) with utils.db_session(self.dbmaker) as session: user = session.query(User).filter(User.username==self.username).first() if form.validate(): name = form.data['keyname'] passphrase = form.data['passphrase'] pub, priv = utils.keygen(name, user.email, passphrase) keyobj = Key(name, user.id, pub, priv) user.keys.append(keyobj) session.add(keyobj) session.add(user) self.request.session.flash(u'successfully generated key %s.' % (name, )) return HTTPFound(location=self.request.route_url('keys'))
def new(request): """new customer """ categories = get_categories() countries = get_countries() form = Form(request, schema=CustomerForm) if "form_submitted" in request.POST and form.validate(): dbsession = DBSession() customer = form.bind(Customer()) dbsession.add(customer) request.session.flash("warning;New Customer is saved!") return HTTPFound(location=request.route_url("customer_list")) return dict(form=FormRenderer(form), categories=categories, countries=countries, action_url=request.route_url("customer_new"))
def listing_category_edit(request): """listing category edit """ title = 'Edit listing category' id = request.matchdict['id'] dbsession = DBSession() category = PropertyCategory.get_by_id(id) if category is None: request.session.flash("warning; Category not found!") return HTTPFound(location=request.route_url("listing_category_list")) form = Form(request, schema=BlogCategoryForm, obj=category) if "form_submitted" in request.POST and form.validate(): form.bind(category) dbsession.add(category) request.session.flash("success;The Category is saved!") return HTTPFound(location=request.route_url("listing_category_list")) action_url = request.route_url("listing_category_edit", id=id) return dict(form=FormRenderer(form), action_url=action_url)
def api_user_uploadfile(request): """用户上传文件,需要传入路径和 """ validators=dict(uploadfile=formencode.validators.FieldStorageUploadConverter(\ not_empty=True,messages=dict(empty=(u'文件不能为空' )))) form = Form(request, validators=validators, state=State(request=request)) if form.validate(): try: path = "frostcms/upload" if not os.path.exists(path): os.makedirs(path) extension = form.data['uploadfile'].filename.split('.')[-1:][0] uid = uuid.uuid1() filename = "%s.%s" % (uid, extension) filepath = os.path.join(path, filename).replace("\\", "/") myfile = open(filepath, 'wb') form.data['uploadfile'].file.seek(0) while 1: tmp = form.data['uploadfile'].file.read(2 << 16) if not tmp: break myfile.write(tmp) myfile.close() fsfile = Fsfile() fsfile.id = uid fsfile.userid = request.user.id fsfile.createtime = time.time() fsfile.filename = form.data['uploadfile'].filename fsfile.filepath = filepath conn = DBSession() conn.add(fsfile) conn.flush() returnStr = str( dict(fsfileid=str(uid), filename=str(fsfile.filename))) #returnStr="<body><pre>"+str(result)+"</pre></body>" response = request.response response.headers['Pragma'] = 'no-cache' response.headers['Cache-Control'] = 'no-cache' response.headers['Expires'] = '0' response.headers['Content-Type'] = "text/html" response.write(returnStr) return response except Exception, e: return dict(code=301, error=u'参数错误')
def idea_add(request): target = request.GET.get('target') session = DBSession() if target: target = Idea.get_by_id(target) if not target: return HTTPNotFound() kind = 'comment' else: kind = 'idea' form = Form(request, schema=AddIdeaSchema) if 'form.submitted' in request.POST and form.validate(): author_username = authenticated_userid(request) author = User.get_by_username(author_username) idea = Idea( target=target, author=author, title=form.data['title'], text=form.data['text'] ) tags = Tag.create_tags(form.data['tags']) if tags: idea.tags = tags session.add(idea) redirect_url = route_url('idea', request, idea_id=idea.idea_id) return HTTPFound(location=redirect_url) login_form = login_form_view(request) return { 'title': 'add an idea', 'form': FormRenderer(form), 'toolbar': toolbar_view(request), 'cloud': cloud_view(request), 'latest': latest_view(request), 'login_form': login_form, 'target': target, 'kind': kind, }
def pyforum_message_view(self): id_topic = self.request.matchdict['id_topic'] topic_title = self.request.matchdict['topic_title'] topics = Message.objects().filter(topic__icontains=id_topic) form = Form(self.request,schema=MessageSchema()) if form.validate(): context = {'name' : form.data['name'], 'description': form.data['description'], 'topic': id_topic} Message.add(context) return HTTPFound(location='/message_list/{0}/{1}'.format(id_topic,topic_title)) return {'title': 'List View PyForum', 'topics':topics, 'id_topic':id_topic, 'topic_title':topic_title, 'form' : FormRenderer(form) }
def location_add(request): form = Form(request, schema=LocationSchema()) if form.validate(): location = form.bind(models.Location()) with transaction.manager: models.DBSession.add(location) locations = models.DBSession.query(models.Location).all() locations_list = [(location.id, location.name) for location in locations] return { "page": "Locations", "items": locations_list, "headings": headings } else: print form.all_errors() print form.errors_for('parent') print "Form validation failed"
def api_mentor_assignment_overmark(request): validators = dict(assignmentid=formencode.validators.Int(not_empty=True)) form = Form(request, validators=validators, state=State(request=request)) if form.validate(): conn = DBSession() assignment = conn.query(Assignment).filter( Assignment.id == form.data['assignmentid']).first() if assignment: assignment.state = 2 assignmentuploads = conn.query(AssignmentUpload).filter( AssignmentUpload.assignmentid == form.data['assignmentid']).all() for assignmentupload in assignmentuploads: assignmentupload.state = 2 conn.flush() return dict(return_url="/mentor/assignment/list") return dict(code=1401, error=u'作业已经不存在') return dict(code=101, error=form.errors)
def edit(request): """country edit """ id = request.matchdict['id'] dbsession = DBSession() country = dbsession.query(Country).filter_by(id=id).one() if country is None: request.session.flash("error;Country not found!") return HTTPFound(location=request.route_url("country_list")) form = Form(request, schema=CountryForm, obj=country) if "form_submitted" in request.POST and form.validate(): form.bind(country) dbsession.add(country) request.session.flash("warning;The Country is saved!") return HTTPFound(location=request.route_url("country_list")) action_url = request.route_url("country_edit", id=id) return dict(form=FormRenderer(form), action_url=action_url)
def view_blogpost_edit(self): form = Form(self.request, schema=BlogPostSchema, state=State(request=self.request)) if form.validate(): self.message = msg['saved'] title = self.request.params[u'title'] text = self.request.params[u'text'] self.context.title = title self.context.text = text _dict = { 'project': '', 'title': self.context.title, 'text': self.context.text, 'form': FormRenderer(form), 'message': self.message } return dict(self.base_dict.items() + _dict.items())
def view_blog_remove(self): """ The Blog can be removed from this view """ form = Form(self.request, schema=BaseSchema, state=State(request=self.request)) self.message = "Edit %s" % self.context.name if form.validate(): return HTTPFound(location=resource_url(self.context.__parent__, self.request)) _dict = { 'page': self.context, 'blogname': self.context.name, 'message': self.message, 'form': FormRenderer(form) } return dict(self.base_dict.items() + _dict.items())
def view_edit(self): title = get_param(self.request, 'title', self.context.title) text = get_param(self.request, 'text', self.context.text) form = Form(self.request, schema=PageEditSchema, state=State(request=self.request)) if form.validate(): self.message = msg['saved'] self.context.text = text self.context.title = title _dict = { 'title': title, 'text': text, 'form': FormRenderer(form), 'message': self.message } return dict(self.base_dict.items() + _dict.items())
def passforgot(request): form = Form(request, schema=ForgotPasswordForm) if 'form_submitted' in request.POST and form.validate(): user = Users.get_by_email(form.data['email']) if user: timestamp = time.time() + 3600 hmac_key = hmac.new( '%s:%s:%d' % (str(user.id), 'r5$55g35%4#$:l3#24&', timestamp), user.email).hexdigest()[0:10] time_key = base64.urlsafe_b64encode('%d' % timestamp) email_hash = '%s%s' % (hmac_key, time_key) email_forgot(request, user.id, user.email, email_hash) request.session.flash('success; Password reset email sent') return HTTPFound(location=request.route_url('login')) request.session.flash('danger; No user with the given email address') return HTTPFound(location=request.route_url('login')) request.session.flash('danger; No such user') return HTTPFound(location=request.route_url('login'))
def emailage(request): camefrom = request.params.get('camefrom') listing = Listings.get_by_name(camefrom) form = Form(request, schema=MailAgentSchema) if 'submit' in request.POST and form.validate(): receiver = listing.user.email name = form.data['fullname'] phone = form.data['mobile'] email = form.data['email'] sender = "%s via nairabricks.com <*****@*****.**>" % name subject = "Contact Request from %s via nairabricks.com" % name content = "<p>I am Interested in your listing at nairabricks.com. I will like to know more about %s in %s. Please get in touch with me</p>" % ( listing.title, listing.address) footer = "<small>Phone: %s</small>" % phone + "<br/>" msg_body = "<html><head><title>"+subject+"</title></head><body>"+\ "Concerning listing Number %s"%listing.serial +\ "<br/>%s <br/>%s"%(content,footer)+\ "</body></html>" extra_headers = {"Reply-To": '%s <%s>' % (name, email)} html_email_sender(request, recipients=receiver, subject=subject, body=msg_body, sender=sender, extra_headers=extra_headers) if request.is_xhr: html = """<div class="alert alert-success alert-dismissable col-xs-12"> <button type="button" class="close" data-dismiss="alert" aria-hidden="true">×</button> Email Sent </div>""" return Response(html) request.session.flash("success; Email sent") return HTTPFound( location=request.route_url('property_view', name=camefrom)) if request.is_xhr: html = """<div class="alert alert-success alert-dismissable col-xs-12"> <button type="button" class="close" data-dismiss="alert" aria-hidden="true">×</button> Email not sent </div>""" return Response(html) request.session.flash("danger; Email not sent") return HTTPFound( location=request.route_url('property_view', name=camefrom))
def share_file(self): form = Form(self.request, schema=forms.PassphraseSchema) if 'form.submitted' in self.request.POST and form.validate(): passphrase = form.data['passphrase'] query_file = os.path.join(self.storage_dir, self.username, self.filename) share_user = self.request.params['share_user'] with utils.db_session(self.dbmaker) as session: owner = session.query(User).filter(User.username==self.username).one() f = session.query(File).filter(File.name==self.filename).one() u = session.query(User).filter(User.username==share_user).first() if u is None: del f.shared_users[:] else: for key in u.keys: f.keys.append(key) session.add(f) owner_pubs = [k.public_key for k in owner.keys] owner_privs = [k.private_key for k in owner.keys] recipients = owner_pubs + [k.public_key for k in f.keys] with open(query_file, 'rb') as o: data = o.read() decrypted = utils.decrypt(data, owner_privs, owner_pubs, passwd) with tempfile.NamedTemporaryFile() as tmp: tmp.write(decrypted) tmp.flush() tmp.seek(0) encrypted = utils.encrypt(tmp, recipients) tmp = tempfile.NamedTemporaryFile(dir=self.storage_dir, delete=False) tmp.write(encrypted) os.rename(tmp.name, query_file) self.request.session.flash( u'successfully shared file: %s with user %s' % (self.filename, share_user) ) return HTTPFound(location=self.request.route_url('view_files')) with utils.db_session(self.dbmaker) as session: sharable_users = session.query(User).filter(User.sharable==True) sharable_users = sharable_users.filter(User.username!=self.username).all() sharable_users = [u.username for u in sharable_users] return dict( username=self.username, filename=self.filename, sharable_users=sharable_users )
def contact(request): form = Form(request, schema=ContactUs) if 'submit' in request.POST and form.validate(): name = form.data['fullname'] email = form.data['email'] body = form.data['body'] subject = "Contact Request by %s" % name extra_headers = {"Reply-To": '%s <%s>' % (name, email)} html_email_sender( request, recipients="*****@*****.**", subject=subject, body=body, extra_headers=extra_headers, sender="*****@*****.**", ) request.session.flash('info;Email sent, thank you for contacting us') return HTTPFound(location="/") return dict(title="contact us", form=FormRenderer(form))
def restore_account_view(request): form = Form(request, schema=RestoreUserSchema) if form.validate(): token = uuid.uuid4().hex url = request.route_url('restore_password', token=token) mail_message = "Restore password with link\n{}\nif you accidently get this mail you can ignore it".format( url) user = User() form.bind(user) user = request.dbsession.query(User).filter( User.email == user.email).first() log.debug(user) if user is None: request.session.flash( 'warning; Cand find user with that username or email') return { 'form': FormRenderer(form), } if user.group == Groups.admin: request.session.flash( 'warning; admin cant restore password you need to use sever scripts to delete admin and create new one' ) return HTTPFound(request.route_path('home')) user.token = token mailer = request.mailer message = Message(subject="Eschool, create account", sender="*****@*****.**", recipients=[user.email], body=mail_message) mailer.send(message) request.session.flash("success; Message with restore link sent") return HTTPFound(request.route_path('home')) return { 'form': FormRenderer(form), }
def view_login(self): """ Login view """ login_url = resource_url(self.request.context, self.request, 'login') referrer = self.request.url if referrer == login_url: # never use the login form itself as came_from referrer = '/' came_from = self.request.params.get('came_from', referrer) username = '' password = '' # Create form by using schemas with validations form = Form(self.request, schema=LoginSchema, state=State(request=self.request), defaults={'klass': 'class'}) if form.validate(): username = self.request.params['username'] password = self.request.params['password'] try: if self.context['users'][username].validate_password(password): headers = remember(self.request, username) return HTTPFound(location=came_from, headers=headers) except KeyError: pass self.message = msg['login_failed'] if self.logged_in: self.message = msg['logged_in_as'] + " " + self.logged_in + ". " if type(self.context) == HTTPForbidden: self.message += msg['content_forbidden'] _dict = { 'url': self.request.application_url + 'login', 'came_from': came_from, 'username': username, 'password': password, 'form': FormRenderer(form), 'message': self.message } return dict(self.base_dict.items() + _dict.items())
def post(self, schema, data): # # ファイルアップロード用のスキーマ # form = Form(data, schema=schema) if form.validate(): # # トランザクションの開始 # with transaction.manager: # # セッションの作成 # session = Session() # # ファイル名、ファイルのデータ取得 # storage = form.request.params.getone('file') model = self._Model(**{ 'name': storage.filename, 'data': storage.file.read(), }) # # セッションに要素の追加 # session.add(model) # # 登録 # session.flush() # # 辞書として返す # return model.to_dict() # # 失敗した場合の処理 # return HTTPNotFound()
def api_mentor_courseware_add(request): conn = DBSession() validators=dict(fsfileid=formencode.validators.String(not_empty=True,min=16,messages=dict(empty=(u'文件不能为空' ))),\ title=formencode.validators.String(not_empty=True,messages=dict(empty=(u'标题不能为空'))),\ description=formencode.validators.String(not_empty=True,messages=dict(empty=(u'描述不能为空')))) form = Form(request, validators=validators, state=State(request=request)) if form.validate(): mentor = conn.query(Mentor).filter( Mentor.userid == request.user.id).first() courseware = Courseware() courseware.title = form.data['title'] courseware.description = form.data['description'] courseware.createtime = time.time() courseware.mentorid = mentor.id courseware.fsfileid = form.data['fsfileid'] conn.add(courseware) conn.flush() return dict(return_url='/mentor/courseware/list') return dict(code=101, error=form.errors)