def test_get(self): from pyramid_simpleform import State obj = State(foo="bar") self.assert_(obj.get("foo") == "bar") self.assert_(obj.get("bar", "foo") == "foo")
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 test_setitem(self): from pyramid_simpleform import State obj = State() obj['foo'] = "bar" self.assert_(obj['foo'] == 'bar') self.assert_(obj.foo == 'bar')
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 __init__(self, request): def formencode_translator(x): if not isinstance(x, TranslationString): x = fe_tsf(x) return gettext(x, request) self.form = Form(request, state=State(_=formencode_translator, request=request)) self.renderer = CiocFormRenderer(self.form) self._defaults = None
def api_user_change_password(request): """用户修改密码api """ form = Form(request, defaults={}, schema=ChangePasswordSchema(), state=State(request=request)) if form.validate(): conn = DBSession() request.user.password = md5(form.data['newpassword']) conn.flush() return {} return dict(code=101, error=FormRenderer(form).errorlist())
def create_note(request): user = get_current_user(request) form = Form( request, schema=NoteSchema(), state=State(user=user)) if form.validate(): note = form.bind(Note()) note.user = user DBSession.add(note) request.session.flash(u'Note is successfully created', 'success') return HTTPFound(location=request.route_url('notes')) return _response_dict( request, renderer=FormRenderer(form) )
def settings(request): user = get_current_user(request) form = Form( request, ChangePasswordSchema(), state=State(user=user) ) if form.validate(): user.password = form.data['password'] DBSession.add(user) request.session.flash(u'Password was successfully changed', 'success') return HTTPFound(location=request.route_url('settings')) return _response_dict( request, renderer=FormRenderer(form) )
def api_mentor_assignment_markupload(request): validators = dict(uploadid=formencode.validators.Int(not_empty=True), mark=formencode.validators.Number(not_empty=True)) form = Form(request, validators=validators, state=State(request=request)) if form.validate(): conn = DBSession() assignmentupload = conn.query(AssignmentUpload).filter( AssignmentUpload.id == form.data['uploadid']).first() if assignmentupload: assignmentupload.state = 1 assignmentupload.mark = form.data['mark'] conn.flush() return {} return dict(code=1401, error=u'作业已经不存在') return dict(code=101, error=form.errors)
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 test_errorlist_with_custom_localizer(self): from pyramid_simpleform import Form from pyramid_simpleform import State from pyramid_simpleform.renderers import FormRenderer request = testing.DummyRequest() request.method = "POST" state = State(_=lambda s: s.upper()) form = Form(request, SimpleFESchema, state=state) form.validate() renderer = FormRenderer(form) self.assertEqual(renderer.errorlist('name'), '<ul class="error"><li>MISSING VALUE</li></ul>')
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 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 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 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)
def view_news_item_edit(self): form = Form(self.request, schema=NewsCreateSchema, state=State(request=self.request)) title = get_param(self.request, 'title', _return=self.context.title) text = get_param(self.request, 'text', _return=self.context.text) image_url = get_param(self.request, 'image_url', _return=self.context.image_url) if form.validate(): self.context.title = title self.context.text = text self.context.image_url = image_url self.message = msg['saved'] _dict = { 'title': title, 'content': text, 'image_url': image_url, 'form': FormRenderer(form), } return dict(self.base_dict.items() + _dict.items())
def view_news_edit(self): form = Form(self.request, schema=BaseSchema, state=State(request=self.request)) if form.validate(): # Filter checkbox-parameters from request 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 = { 'context_url': resource_url(self.context, self.request), 'form': FormRenderer(form), 'message': self.message, } return dict(self.base_dict.items() + _dict.items())
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 view_news_create(self): form = Form(self.request, schema=NewsCreateSchema, state=State(request=self.request)) title = get_param(self.request, 'title') text = get_param(self.request, 'text') image_url = get_param(self.request, 'image_url') if form.validate(): item_context = self.context.add(title, text, image_url, self.logged_in) return HTTPFound(location=resource_url(item_context, self.request)) _dict = { 'page': self.context, 'context_url': resource_url(self.context, self.request), 'form': FormRenderer(form), 'title': title, 'content': text, 'image_url': image_url, } return dict(self.base_dict.items() + _dict.items())
def update_note(request): user = get_current_user(request) note_id = request.matchdict['note_id'] note = DBSession.query(Note).filter(Note.id == note_id).first() form = Form( request, schema=NoteSchema(), state=State(user=user), obj=note) if form.validate(): note = form.bind(note) DBSession.add(note) request.session.flash(u'Note is successfully updated', 'success') # build redirect url location = request.route_url('notes') if note.pad is not None: location = request.route_url('pad_notes', pad_id=note.pad.id) return HTTPFound(location=location) return _response_dict( request, note=note, renderer=FormRenderer(form) )
def view_blog_create(self): """ View for creating a single blog """ logged_in = authenticated_userid(self.request) form = Form(self.request, schema=BlogCreateSchema, state=State(request=self.request)) blogname = get_param(self.request, 'blogname') text = get_param(self.request, 'text') image_url = get_param(self.request, 'image_url') if form.validate(): blog = self.context.add(blogname, text, image_url, logged_in) return HTTPFound(location=resource_url(blog, self.request)) _dict = { 'form': FormRenderer(form), 'message': self.message, 'blogname': blogname, 'text': text, 'image_url': image_url } return dict(self.base_dict.items() + _dict.items())
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 view_blog_add_post(self): form = Form(self.request, schema=BlogPostSchema, state=State(request=self.request)) message = "" title = get_param(self.request, 'title') text = get_param(self.request, 'text') if form.validate(): post_context = self.context.add(title, text, self.logged_in) return HTTPFound(location=resource_url(post_context, self.request)) _dict = { 'page': self.context, 'blogname': self.context.name, 'text': text, 'title': title, 'message': message, 'form': FormRenderer(form), } return dict(self.base_dict.items() + _dict.items())
def test_get(self): from pyramid_simpleform import State obj = State(foo="bar") self.assert_(obj.get('foo') == 'bar') self.assert_(obj.get('bar', 'foo') == 'foo')
def view_users_edit(self): """ View for editing users. Includes permission handling. """ form = Form(self.request, schema=UsersEditSchema, state=State(request=self.request)) search_results = [] search = get_param(self.request, 'search') if form.validate(): # Loop through all the users and create dict of groups for user in self.context: if search.lower() in self.context[user].username.lower(): search_results.append(self.context[user]) if 'save' in self.request.params.keys() and \ self.request.params['save'] == 'Save': self.message = msg['saved'] # Filter checkbox-parameters from request cbs = [p for p in self.request.params.keys() if u'checkbox' in p] users = [self.request.params[p] for p in self.request.params.keys() if u'user' == p] # new policy for groups updated = {} # check all the checkbox-parameters and # parse them for cb in cbs: username = cb.split(':')[1] try: updated[username] except KeyError: updated[username] = [] updated[username] += [self.request.params[cb]] groups_tool = get_resource('groups', self.request) # Init users as empty first, then update with checkbox-data # TODO: add 'u:user' group? for user in users: groups_tool.flush(user) groups_tool.add_policy(updated) def has_group(group, user, request): """ Check if the user belongs to the group """ return group_names[group] in groupfinder(user.username, request) def sorted_gnames(): """ Sort list of keys to make sure they are in right order """ return sorted(group_names.keys()) _dict = { 'page': self.context, 'form': FormRenderer(form), 'search_results': search_results, 'message': self.message, 'group_names': group_names, 'has_group': has_group, 'sorted_gnames': sorted_gnames(), 'result_count': len(search_results), 'search_term': search } return dict(self.base_dict.items() + _dict.items())
def test_state_not_contains(self): from pyramid_simpleform import State obj = State(foo="bar") self.assert_("bar" not in obj)
def test_getitem(self): from pyramid_simpleform import State obj = State(foo="bar") self.assert_(obj['foo'] == 'bar')
def test_getitem_notfound(self): from pyramid_simpleform import State obj = State() self.assertRaises(KeyError, obj.__getitem__, 'foo')