def userdata_doctype_view(userdata_model, request): """ View used to register doctypes status userdata_model The UserDatas model retrieved through traversal """ if 'submit' in request.params: schema = get_doctypes_form_schema(userdata_model)[0] appstruct = request.POST.items() appstruct = peppercorn.parse(appstruct) try: appstruct = schema.deserialize(appstruct) except colander.Invalid: logger.exception("Error while validating doctype registration") else: node_schema = SQLAlchemySchemaNode(UserDatasSocialDocTypes) for data in appstruct.values(): model = node_schema.objectify(data) request.dbsession.merge(model) request.session.flash( u"Les informations saisies ont bien été enregistrées") return HTTPFound(request.route_path('userdata', id=userdata_model.id))
def vote_view(context, request): logged_in = authenticated_userid(request) schema = BallotSchema().clone() _add_category_schema(context, request, schema) form = Form(schema, buttons=("submit",)) css_resources, js_resources = _form_resources(form) if "submit" in request.POST: controls = request.POST.items() try: form.validate(controls) except (ValidationFailure,), e: # Put the team names back in place cstruct = e.cstruct for vote in cstruct["votes"]: team_id = vote["team_hidden"] team_obj = context["teams"][team_id] team_title = team_obj.title team_descrip = team_obj.description vote["team_title"] = team_title vote["team_members"] = ", ".join(team_obj.member_names()) vote["team_description"] = team_descrip return { "form": e.render(), "css_resources": css_resources, "js_resources": js_resources, "logged_in": logged_in, } results = parse(request.params.items())["votes"] context.results[logged_in] = results context._p_changed = True return HTTPFound(location=request.resource_url(context))
def __call__(self): schema = BusinessTypeMentionEntries().bind(request=self.request) if 'submit' in self.request.params: controls = self.request.params.items() values = peppercorn.parse(controls) logger.debug(values) try: appstruct = schema.deserialize(values) except colander.Invalid: logger.exception(u"Error while validating association datas") self.request.session.flash( u"Une erreur est survenue, veuillez " u"contacter votre administrateur", 'error', ) else: for datas in appstruct['items']: mandatory = datas.get('mandatory') if mandatory is not None: # Facultatif ou obligatoire : on retrouve ou on crée obj = self._find_item(datas, create=True) obj.mandatory = mandatory == 'true' self.request.dbsession.merge(obj) else: # Non utilisé : on supprime l'éventuel existant obj = self._find_item(datas) if obj is not None: self.request.dbsession.delete(obj) self.request.session.flash( u"Vos modifications ont été enregistrées" ) return HTTPFound(self.request.current_route_path())
def edit_team(context, request): logged_in = authenticated_userid(request) schema = TeamSchema().bind(request=request) form = Form(schema, buttons=("submit",)) css_resources, js_resources = _form_resources(form) if "submit" in request.POST: controls = request.POST.items() try: form.validate(controls) except (ValidationFailure,), e: return { "form": e.render(), "css_resources": css_resources, "js_resources": js_resources, "logged_in": logged_in, } params = parse(controls) context.title = params["title"] context.description = params["description"] leader = params["leader"] context.leader = leader members = params["members"] # Add the leader if they didn't add themselves if leader and leader not in members: members.append(leader) context.members = members # TODO: use find by interface here voting_booth = context.__parent__.__parent__ return HTTPFound(location=request.resource_url(voting_booth))
def add_profile(context, request): logged_in = authenticated_userid(request) schema = ProfileAddSchema() form = Form(schema, buttons=("submit",)) css_resources, js_resources = _form_resources(form) if "submit" in request.POST: controls = request.POST.items() try: form.validate(controls) except (ValidationFailure,), e: return { "form": e.render(), "css_resources": css_resources, "js_resources": js_resources, "logged_in": logged_in, } params = parse(controls) first_name = params["first_name"] last_name = params["last_name"] username = params["username"] email = params["email"] password = params["password"]["value"] # Create the profile profile = Profile(first_name=first_name, last_name=last_name, username=username, email=email) # Add the profile object profile.__parent__ = context["profiles"] profile.__name__ = username context["profiles"].add_profile(profile) # Add the user object user_folder = context["users"] user_folder.add(username, username, password) return HTTPFound(location=request.resource_url(context.__parent__))
def sa_add(self): action = self.request.matched_route.name bc = breadcrumbs(self.tname, get_table_verbose_name(self.table), action, self.pk) dbsession = self.request.dbsession try: obj = get_obj(dbsession, self.table, self.pk) except (NoResultFound, KeyError): raise HTTPNotFound form = SacrudForm(obj=obj, dbsession=dbsession, request=self.request, table=self.table)() def options_for_response(form): return dict( form=form.render(), pk=self.pk, obj=obj, breadcrumbs=bc ) if 'form.submitted' in self.request.params: controls = self.request.POST.items() pstruct = peppercorn.parse(controls) if '__formid__' in pstruct: try: deserialized = form.validate_pstruct(pstruct).values() except deform.ValidationFailure as e: return options_for_response(e) data = {k: preprocessing_value(v) for d in deserialized for k, v in d.items()} else: # if not peppercon format data = pstruct try: if action == PYRAMID_SACRUD_UPDATE: obj = self.crud.update(self.pk, data) flash_action = 'updated' else: obj = self.crud.create(data) flash_action = 'created' name = obj.__repr__() dbsession.flush() except SacrudMessagedException as e: self.flash_message(e.message, status=e.status) return self.get_response(options_for_response(form), SACRUD_EDIT_TEMPLATE) except Exception as e: transaction.abort() logging.exception("Something awful happened!") raise e transaction.commit() self.flash_message(_ps( u"You ${action} object of ${name}", mapping={'action': flash_action, 'name': escape(name or '')} )) return HTTPFound( location=self.request.route_url(PYRAMID_SACRUD_LIST, table=self.tname)) return self.get_response(options_for_response(form), SACRUD_EDIT_TEMPLATE)
def add_team(context, request): logged_in = authenticated_userid(request) schema = TeamSchema().bind(request=request) form = Form(schema, buttons=("submit",)) css_resources, js_resources = _form_resources(form) if "submit" in request.POST: controls = request.POST.items() try: form.validate(controls) except (ValidationFailure,), e: return { "form": e.render(), "css_resources": css_resources, "js_resources": js_resources, "logged_in": logged_in, } params = parse(controls) leader = params["leader"] members = params["members"] # Add the leader if they didn't add themselves if leader and leader not in members: members.append(leader) team = Team(title=params["title"], description=params["description"], members=members, leader=leader) team.__parent__ = context context.add_team(team) return HTTPFound(location=request.resource_url(context.__parent__))
def __call__(self): appstruct = parse(self.request.POST.items()) appstruct.pop('csrf_token', None) method = appstruct.pop('method', None) response = {} if method == 'add': principal = appstruct['principal'] if principal.startswith('group:'): if principal in self.root['groups']: self.context.local_roles[principal] = appstruct['roles'] else: response['errors'] = { 'principal': _("That GroupID don't exist") } else: if principal in self.root['users']: self.context.local_roles[principal] = appstruct['roles'] else: response['errors'] = { 'principal': _("That UserID don't exist") } elif method == 'set': self.context.local_roles = appstruct #Validate, return a proper response else: pass #response['errors']? response['principals'] = self.get_principals() return response
def add_voting_booth(context, request): logged_in = authenticated_userid(request) schema = VotingBoothSchema() form = Form(schema, buttons=("submit",)) css_resources, js_resources = _form_resources(form) if "submit" in request.POST: controls = request.POST.items() try: form.validate(controls) except (ValidationFailure,), e: return { "form": e.render(), "css_resources": css_resources, "js_resources": js_resources, "logged_in": logged_in, } values = parse(request.params.items()) start, end = _process_dates(values) voting_booth = VotingBooth(title=values["title"], start=start, end=end, categories=values["categories"]) voting_booth.__parent__ = context # maybe this should be done in the team add view? team_folder = TeamFolder() team_folder.__parent__ = voting_booth team_folder.__name__ = "teams" voting_booth["teams"] = team_folder context.add_booth(voting_booth) return HTTPFound(location=request.resource_url(voting_booth))
def record_attendances_view(context, request): """ Record attendances for the given context (workshop) Special Note : Since we need a special layout in the form (with tabs and lines with the username as header, we can't render it with deform. We use peppercorn's parser and we build an appropriate form in the template """ schema = AttendanceSchema().bind(request=request) if 'submit' in request.params: controls = request.params.items() values = peppercorn.parse(controls) try: appstruct = schema.deserialize(values) except colander.Invalid as e: log.error(u"Error while validating workshop attendance") log.error(e) else: for datas in appstruct['attendances']: account_id = datas['account_id'] timeslot_id = datas['timeslot_id'] obj = Attendance.get((account_id, timeslot_id)) obj.status = datas['status'] request.dbsession.merge(obj) request.session.flash(u"L'émargement a bien été enregistré") url = request.route_path( 'workshop', id=context.id, _query=dict(action="edit"), ) return HTTPFound(url)
def userdata_doctype_view(userdata_model, request): """ View used to register doctypes status userdata_model The UserDatas model retrieved through traversal """ if 'submit' in request.params: schema = get_doctypes_form_schema(userdata_model)[0] appstruct = request.POST.items() appstruct = peppercorn.parse(appstruct) try: appstruct = schema.deserialize(appstruct) except colander.Invalid: logger.exception( "Error while validating doctype registration" ) else: node_schema = SQLAlchemySchemaNode(UserDatasSocialDocTypes) for data in appstruct.values(): model = node_schema.objectify(data) request.dbsession.merge(model) request.session.flash( u"Les informations saisies ont bien été enregistrées" ) return HTTPFound( request.route_path('userdata', id=userdata_model.id) )
def __call__(self): appstruct = parse(self.request.POST.items()) appstruct.pop('csrf_token', None) method = appstruct.pop('method', None) response = {} if method == 'add': principal = appstruct['principal'] if principal.startswith('group:'): if principal in self.root['groups']: self.context.local_roles[principal] = appstruct['roles'] else: response['errors'] = {'principal': _("That GroupID don't exist")} else: if principal in self.root['users']: self.context.local_roles[principal] = appstruct['roles'] else: response['errors'] = {'principal': _("That UserID don't exist")} elif method == 'set': self.context.local_roles = appstruct #Validate, return a proper response else: pass #response['errors']? response['principals'] = self.get_principals() return response
def __call__(self): schema = BusinessTypeMentionEntries().bind(request=self.request) if 'submit' in self.request.params: controls = self.request.params.items() values = peppercorn.parse(controls) logger.debug(values) try: appstruct = schema.deserialize(values) except colander.Invalid: logger.exception(u"Error while validating association datas") self.request.session.flash( u"Une erreur est survenue, veuillez " u"contacter votre administrateur", 'error', ) else: for datas in appstruct['items']: mandatory = datas.get('mandatory') if mandatory is not None: # Facultatif ou obligatoire : on retrouve ou on crée obj = self._find_item(datas, create=True) obj.mandatory = mandatory == 'true' self.request.dbsession.merge(obj) else: # Non utilisé : on supprime l'éventuel existant obj = self._find_item(datas) if obj is not None: self.request.dbsession.delete(obj) self.request.session.flash( u"Vos modifications ont été enregistrées") return HTTPFound(self.request.current_route_path())
def add_featured_links(self, request, zip_file, save_dir): structure = peppercorn.parse(request.POST.items()) if structure.has_key('featuredlinks'): featuredlinks = build_featured_links(structure) if featuredlinks: cnxml = get_cnxml_from_zipfile(zip_file) new_cnxml = add_featuredlinks_to_cnxml(cnxml, featuredlinks) files = get_files_from_zipfile(zip_file) save_cnxml(save_dir, new_cnxml, files) return featuredlinks
def set_data(self, struct=None, obj=None, **kwargs): tmp_struct = {} for field in self.field_names(): if field in struct: tmp_struct[field] = copy.deepcopy(struct[field]) elif hasattr(obj, field): tmp_struct[field] = copy.deepcopy(getattr(obj, field)) elif field in kwargs: tmp_struct[field] = copy.deepcopy(kwargs[field]) self.untrusted_data = peppercorn.parse(tmp_struct.items())
def edit_form_post_view(self): form = self.context.form(self.request) params = {'form': form.render()} def get_reponse(form=None): if form: params['form'] = form return render_to_response(self.context.renderer, params, request=self.request) if 'form.submitted' in self.request.params: controls = self.request.POST.items() pstruct = peppercorn.parse(controls) # Validate form try: deserialized = form.validate_pstruct(pstruct).values() except deform.ValidationFailure as e: return get_reponse(e.render()) data = { k: preprocessing_value(k, v, form) # TODO: optimize it for d in deserialized for k, v in d.items() } # Update object try: if self.context.obj: obj = self.context.crud._add(self.context.obj, data) flash_action = 'updated' else: obj = self.context.crud.create(data) flash_action = 'created' name = obj.__repr__() self.context.dbsession.flush() except SacrudException as e: self.flash_message(e.message, status=e.status) return get_reponse() except Exception as e: self.abort() logging.exception("Something awful happened!") raise e self.commit() # Make response self.flash_message( _ps(u"You ${action} object of ${name}", mapping={ 'action': flash_action, 'name': escape(name or '') })) return self.list_view_response() return get_reponse()
def from_request(self): """ my_form = my_form.from_request(request) Pyramid only """ if self.request.content_type.startswith('application/json'): self.serialized_value = self.request.json_body # TODO possible exceptions else: self.serialized_value = peppercorn.parse(list(self.request.POST.items())) return self
def __call__(self): """ The main entry for our view """ logger.info("Calling the treasury files view") filetype = self.request.matchdict['filetype'] year = self.request.matchdict['year'] month = self.request.matchdict['month'] root_directory = get_root_directory(self.request) root_path = os.path.join(root_directory, filetype, year, month) result = self._base_result_dict(filetype) datas = self.collect_files(root_path) result['datas'] = datas if 'submit' in self.request.params: logger.info(" -> Datas were submitted") # L'utilisateur a demandé l'envoi de mail try: appstruct = peppercorn.parse(self.request.params.items()) form_datas = MailSendingSchema().deserialize(appstruct) except colander.Invalid as e: logger.exception(u" - Submitted datas are invalid") result.update(self.request.params) result['errors'] = e.asdict() else: logger.info(" + Submitted datas are valid") mails = self._prepare_mails( datas, form_datas, root_path, year, month, ) # On check qu'il y a au moins une entrée pour laquelle on va # envoyer un mail if len(mails) == 0: result['errors'] = { 'companies': u"Veuillez sélectionner au moins \ une entreprise" } result.update(form_datas) return result force = form_datas.get('force', False) return self._send_mails(mails, force) return result
def update_cnxml(self, request, zip_file, metadata=None): # retrieve the cnxml from the zip file on the server # add feature feature links to cnxml (later we will want to add metadata as well) # return the updated cnxml zip_cnxml_file = get_cnxml_from_zipfile(zip_file) updated_cnxml = "\n".join(zip_cnxml_file.readlines()) structure = peppercorn.parse(request.POST.items()) if structure.has_key('featuredlinks'): featuredlinks = build_featured_links(structure) if featuredlinks: updated_cnxml = add_featuredlinks_to_cnxml(zip_cnxml_file, featuredlinks) return updated_cnxml
def account_view(self): """This is the settings form for the user. The first time a user logs in, they are taken here so we can get their first and last name. """ # Special case when the db was blown away if self.user_id is not None and self.user is None: return self.logout() section_name = 'account' schema = SettingsSchema() form = Form(schema, buttons=('submit',)) css_resources, js_resources = self.form_resources(form) if 'submit' in self.request.POST: controls = self.request.POST.items() try: form.validate(controls) except ValidationFailure as e: msg = 'There was an error saving your settings.' self.request.session.flash(msg, queue='error') return { 'form': e.render(), 'css_resources': css_resources, 'js_resources': js_resources, 'section': section_name, } values = parse(self.request.params.items()) # Update the user with transaction.manager: self.user.first_name = values.get('first_name', u'') self.user.last_name = values.get('last_name', u'') self.user.time_zone = values.get('time_zone', u'US/Eastern') DBSession.add(self.user) self.request.session.flash( 'Settings updated successfully', queue='success', ) return HTTPFound('/list') # Get existing values if self.user is not None: appstruct = dict( first_name=self.user.first_name, last_name=self.user.last_name, time_zone=self.user.time_zone, ) else: appstruct = {} return { 'form': form.render(appstruct), 'css_resources': css_resources, 'js_resources': js_resources, 'section': section_name, }
def account_view(self): """This is the settings form for the user. The first time a user logs in, they are taken here so we can get their first and last name. """ # Special case when the db was blown away if self.user_id is not None and self.user is None: return self.logout() section_name = 'account' schema = SettingsSchema() form = Form(schema, buttons=('submit', )) css_resources, js_resources = self.form_resources(form) if 'submit' in self.request.POST: controls = self.request.POST.items() try: form.validate(controls) except ValidationFailure as e: msg = 'There was an error saving your settings.' self.request.session.flash(msg, queue='error') return { 'form': e.render(), 'css_resources': css_resources, 'js_resources': js_resources, 'section': section_name, } values = parse(self.request.params.items()) # Update the user with transaction.manager: self.user.first_name = values.get('first_name', u'') self.user.last_name = values.get('last_name', u'') self.user.time_zone = values.get('time_zone', u'US/Eastern') DBSession.add(self.user) self.request.session.flash( 'Settings updated successfully', queue='success', ) return HTTPFound('/list') # Get existing values if self.user is not None: appstruct = dict( first_name=self.user.first_name, last_name=self.user.last_name, time_zone=self.user.time_zone, ) else: appstruct = {} return { 'form': form.render(appstruct), 'css_resources': css_resources, 'js_resources': js_resources, 'section': section_name, }
def update_cnxml(self, request, zip_file, metadata=None): # retrieve the cnxml from the zip file on the server # add feature feature links to cnxml (later we will want to add metadata as well) # return the updated cnxml zip_cnxml_file = get_cnxml_from_zipfile(zip_file) updated_cnxml = "\n".join(zip_cnxml_file.readlines()) structure = peppercorn.parse(request.POST.items()) if structure.has_key('featuredlinks'): featuredlinks = build_featured_links(structure) if featuredlinks: updated_cnxml = add_featuredlinks_to_cnxml( zip_cnxml_file, featuredlinks) return updated_cnxml
def set_data(self, struct=None, obj=None, **kwargs): """ Sets the data for form """ if struct is None: struct = {} parsed_data = peppercorn.parse(struct.items()) if '_ziggurat_form_field_' in parsed_data: self._non_coerced_data = parsed_data['_ziggurat_form_field_'] else: self._non_coerced_data = parsed_data self._coerced_data_holder = copy.deepcopy(self._non_coerced_data) self.set_nodes() coerce_recursive(self.widget, self)
def edit_form_post_view(self): form = self.context.form(self.request) params = {'form': form.render()} def get_reponse(form=None): if form: params['form'] = form return render_to_response( self.context.renderer, params, request=self.request ) if 'form.submitted' in self.request.params: controls = self.request.POST.items() pstruct = peppercorn.parse(controls) # Validate form try: deserialized = form.validate_pstruct(pstruct).values() except deform.ValidationFailure as e: return get_reponse(e.render()) data = {k: preprocessing_value(k, v, form) # TODO: optimize it for d in deserialized for k, v in d.items()} # Update object try: if self.context.obj: obj = self.context.sacrud._add(self.context.obj, data) flash_action = 'updated' else: obj = self.context.sacrud.create(data) flash_action = 'created' name = obj.__repr__() self.context.dbsession.flush() except SacrudException as e: self.flash_message(e.message, status=e.status) return get_reponse() except Exception as e: self.abort() logging.exception("Something awful happened!") raise e self.commit() # Make response self.flash_message(_ps( u"You ${action} object of ${name}", mapping={'action': flash_action, 'name': escape(name or '')} )) return self.list_view_response() return get_reponse()
def __call__(self): """ The main entry for our view """ logger.info("Calling the treasury files view") filetype = self.request.matchdict['filetype'] year = self.request.matchdict['year'] month = self.request.matchdict['month'] root_directory = get_root_directory(self.request) root_path = os.path.join(root_directory, filetype, year, month) result = self._base_result_dict(filetype) datas = self.collect_files(root_path) result['datas'] = datas if 'submit' in self.request.params: logger.info(" -> Datas were submitted") # L'utilisateur a demandé l'envoi de mail try: appstruct = peppercorn.parse(self.request.params.items()) form_datas = MailSendingSchema().deserialize(appstruct) except colander.Invalid as e: logger.exception(u" - Submitted datas are invalid") result.update(self.request.params) result['errors'] = e.asdict() else: logger.info(" + Submitted datas are valid") mails = self._prepare_mails( datas, form_datas, root_path, year, month, ) # On check qu'il y a au moins une entrée pour laquelle on va # envoyer un mail if len(mails) == 0: result['errors'] = { 'companies': u"Veuillez sélectionner au moins \ une entreprise"} result.update(form_datas) return result force = form_datas.get('force', False) return self._send_mails(mails, force) return result
def get_raw_featured_links(self, request): data = peppercorn.parse(request.POST.items()) if data is None or len(data.get('featuredlinks')) < 1: return [] # get featured links from data tmp_links = {} # first we organise the links by category for details in data['featuredlinks']: category = details['fl_category'] tmp_list = tmp_links.get(category, []) tmp_list.append(details) tmp_links[category] = tmp_list return tmp_list
def _post(self, form, controls=None): '''You may override this method in subclasses to do something special when the request method is POST. ''' controls = peppercorn.parse(controls or self.request.POST.items()) controls = self._preprocess_controls(controls) try: appstruct = form.validate_pstruct(controls) except d.ValidationFailure as e: self.status = 'invalid' return self._invalid(e, controls) else: self.status = 'valid' appstruct.pop('csrf_token', None) # Discard the CSRF token return self._valid(form=form, controls=appstruct)
def _get_sorted_component_names(self, request): """ Returns a list of (component names, params) from request """ data = parse(request.POST.items()) schemas = [] # establish position of widgets for k, v in self.request.POST.items(): if (k == '__start__') and (':mapping' in v): sk = v.split(':')[0] parms = data[sk] if isinstance(parms, dict) and parms.get('schema_type', None): schemas.append((sk, data[sk])) return schemas
def post_index(self): pstruct = peppercorn.parse(self.request.POST.items()) form = Form(BookListSchema()) try: data = form.validate(pstruct) log.info(data) except FormException as e: return dict( data=pstruct, errors=e.prepare() ) return dict( data=pstruct )
def set_data(self, struct=None, obj=None, **kwargs): """ Sets the data for form """ parsed_data = peppercorn.parse(struct.items()) if '_ziggurat_form_field_' in parsed_data: self.non_coerced_data = parsed_data['_ziggurat_form_field_'] else: self.non_coerced_data = parsed_data self.coerced_data_holder = copy.deepcopy(self.non_coerced_data) self.set_nodes() def coerce_recursive(widget, form): widget.coerce() if widget.children: for child_widget in widget.children: coerce_recursive(child_widget, form) coerce_recursive(self.widget, self)
def form_class(self, schema, **kwargs): data = parse(self.request.POST.items()) schemas = self._schemas() schemas = self._apply_schema_edits(schemas, data) for s in schemas: schema.add(s) # move the pipeline components select widget to the bottom w = schema.__delitem__('pipeline_components') schema.add(w) kwargs.update(dict(self.form_options)) self.form = Form(schema, renderer=deform_renderer, **kwargs) return self.form
def validate(self, force_validate=False, params=None): """ Runs validation and returns True/False whether form is valid. This will check if the form should be validated (i.e. the request method matches) and the schema validates. Validation will only be run once; subsequent calls to validate() will have no effect, i.e. will just return the original result. The `errors` and `data` dicts will be updated accordingly. `force_validate` : will run validation regardless of request method. `params` : dict or MultiDict of params. By default will use **request.POST** (if HTTP POST) or **request.params**. """ if self.is_validated: return not(self.errors) if not force_validate: if self.method and self.method != self.request.method: return False if params is None: if self.method == "POST": params = self.request.POST else: params = self.request.params params = peppercorn.parse(params.items()) self.data.update(params) if self.schema: try: self.data = self.schema.deserialize(params) except colander.Invalid, e: self.errors = e.asdict()
def index(): if flask.request.method == "POST": #Please note the "multi=True" controlData = peppercorn.parse(flask.request.form.items(multi=True)) print "controlData", controlData #this is it!!!!!!!!!!!!!!!!!!!! #Now, create the form to be returned to the user according to the schema defined before and populating it with the data that were posted by the user and processed by the application so far. form = deform.Form(topList(), buttons=('submit', )).render(controlData) aMess = "Processed Data" #Just a string to define a message return flask.render_template("index.html", theForm=form, title="HI") else: #Just return an empty form schema = Schema() form = deform.Form(schema, buttons=('submit', )).render() return flask.render_template("index.html", theForm=form, theMessage="HI")
def form_view(request): itemSchema = ItemSchema() itemForm = Form(itemSchema, buttons=('submit',), formid='itemForm', counter=counter) categorySchema = CategorySchema() categoryForm = Form(categorySchema, buttons=('submit',), formid='categoryForm', counter=counter) purchaseSchema = PurchaseSchema() purchaseForm = Form(purchaseSchema, buttons=('submit',), formid='purchaseForm', counter=counter) db = sqlite() dbfunctions = { 'itemForm': {'add': db.addItem}, 'categoryForm': {'add':db.addCategory}, 'purchaseForm': {'add':db.addPurchase} } html = [] if 'submit' in request.POST: posted_formid = request.POST['__formid__'] for (formid, form) in [('itemForm', itemForm), ('categoryForm', categoryForm), ('purchaseForm', purchaseForm)]: if formid == posted_formid: controls = list(request.POST.items()) pstruct = peppercorn.parse(controls) try: form.validate(controls) pprint.pprint(pstruct) dbAdd = dbfunctions.get(formid).get('add') dbAdd(pstruct) url = request.application_url return HTTPFound(location=url) except ValidationFailure as e: return {'form':e.render()} else: form.schema.update() html.append(form.render()) else: for form in itemForm, categoryForm, purchaseForm: form.schema.update() html.append(form.render()) html = ''.join(html) return {'form':html}
def edit_voting_booth(context, request): logged_in = authenticated_userid(request) schema = VotingBoothSchema() form = Form(schema, buttons=("submit",)) css_resources, js_resources = _form_resources(form) if "submit" in request.POST: controls = request.POST.items() try: form.validate(controls) except (ValidationFailure,), e: return { "form": e.render(), "css_resources": css_resources, "js_resources": js_resources, "logged_in": logged_in, } values = parse(request.params.items()) start, end = _process_dates(values) context.title = values["title"] context.start = start context.end = end context.categories = values["categories"] return HTTPFound(location=request.resource_url(context))
def parse_from_peppercorn(self, tuples): self.data = {'data': peppercorn.parse(tuples)}
def validate(self, controls, subcontrol=None): """ Validate the set of controls returned by a form submission against the schema associated with this field or form. ``controls`` should be a *document-ordered* sequence of two-tuples that represent the form submission data. Each two-tuple should be in the form ``(key, value)``. ``node`` should be the schema node associated with this widget. For example, using WebOb, you can compute a suitable value for ``controls`` via:: request.POST.items() Or, if you're using a ``cgi.FieldStorage`` object named ``fs``, you can compute a suitable value for ``controls`` via:: controls = [] if fs.list: for control in fs.list: if control.filename: controls.append((control.name, control)) else: controls.append((control.name, control.value)) Equivalent ways of computing ``controls`` should be available to any web framework. When the ``validate`` method is called: - if the fields are successfully validated, a data structure represented by the deserialization of the data as per the schema is returned. It will be a mapping. - If the fields cannot be successfully validated, a :exc:`deform.exception.ValidationFailure` exception is raised. The typical usage of ``validate`` in the wild is often something like this (at least in terms of code found within the body of a :mod:`pyramid` view function, the particulars will differ in your web framework):: from webob.exc import HTTPFound from deform.exception import ValidationFailure from deform import Form import colander from my_application import do_something class MySchema(colander.MappingSchema): color = colander.SchemaNode(colander.String()) schema = MySchema() def view(request): form = Form(schema, buttons=('submit',)) if 'submit' in request.POST: # form submission needs validation controls = request.POST.items() try: deserialized = form.validate(controls) do_something(deserialized) return HTTPFound(location='http://example.com/success') except ValidationFailure as e: return {'form':e.render()} else: return {'form':form.render()} # the form just needs rendering .. warning:: ``form.validate(controls)`` mutates the ``form`` instance, so the ``form`` instance should be constructed (and live) inside one request. If ``subcontrol`` is supplied, it represents a named subitem in the data returned by ``peppercorn.parse(controls)``. Use this subitem as the pstruct to validate instead of using the entire result of ``peppercorn.parse(controls)`` as the pstruct to validate. For example, if you've embedded a mapping in the form named ``user``, and you want to validate only the data contained in that mapping instead if all of the data in the form post, you might use ``form.validate(controls, subcontrol='user')``. """ pstruct = peppercorn.parse(controls) if subcontrol is not None: pstruct = pstruct.get(subcontrol, colander.null) return self.validate_pstruct(pstruct)
def sa_add(self): bc = breadcrumbs(self.tname, get_table_verbose_name(self.table), 'sa_create') if self.pk: bc = breadcrumbs(self.tname, get_table_verbose_name(self.table), 'sa_update', id=self.pk) dbsession = self.request.dbsession try: obj = get_obj(dbsession, self.table, self.pk) except (NoResultFound, KeyError): raise HTTPNotFound form = SacrudForm(obj=obj, dbsession=dbsession, request=self.request, table=self.table)() def get_responce(form): return dict(form=form.render(), pk=self.pk, obj=obj, breadcrumbs=bc, pk_to_list=pk_to_list) if 'form.submitted' in self.request.params: controls = self.request.POST.items() pstruct = peppercorn.parse(controls) if '__formid__' in pstruct: try: deserialized = form.validate_pstruct(pstruct).values() except deform.ValidationFailure as e: return get_responce(e) data = { k: preprocessing_value(v) for d in deserialized for k, v in d.items() } else: # if not peppercon format data = pstruct try: if self.pk: obj = self.crud.update(self.pk, data) else: obj = self.crud.create(data) name = obj.__repr__() dbsession.flush() except SacrudMessagedException as e: self.flash_message(e.message, status=e.status) return get_responce(form) except Exception as e: transaction.abort() logging.exception("Something awful happened!") raise e transaction.commit() if self.pk: self.flash_message( _ps(u"You updated object of ${name}", mapping={'name': escape(name or '')})) else: self.flash_message( _ps("You created new object of ${name}", mapping={'name': escape(name or '')})) return HTTPFound( location=self.request.route_url('sa_list', table=self.tname)) return get_responce(form)
def experimentForm(request): """ project form page """ class All(colander.MappingSchema): setup_schema(None,experiment) experimentSchema=experiment.__colanderalchemy__ setup_schema(None,experimental_conditions) conditionsSchema=experimental_conditions.__colanderalchemy__ setup_schema(None,data_aquisition) data_aquisition_Schema=data_aquisition.__colanderalchemy__ tables = All() form = deform.Form(tables,buttons=('submit',)) if 'submit' in request.POST: #map columns controls = request.POST.items() controls = request.POST.items() #call validate pstruct = peppercorn.parse(controls) print(pstruct) try: appstruct = form.validate(controls) experiment_description = request.params['experiment_description'] exp = pstruct['experimentSchema'] # try to add to database print(exp) page = experiment(project_ID=0,**exp) request.dbsession.add(page) experiment_description= request.params['experiment_description'] #retrieve last db entry for experiment ID id = request.dbsession.query(experiment).order_by(experiment.experiment_ID.desc()).first()#link experiment column to related foreign keys #experiment_id = request.dbsession.query(experiment).filter_by(experiment_description=experiment_description).first() experiment_id = int(id.experiment_ID) experimental_cond = pstruct['conditionsSchema'] page = experimental_conditions(experiment_ID=experiment_id, **experimental_cond) request.dbsession.add(page) data_aq = pstruct['data_aquisition_Schema'] page = data_aquisition(**data_aq, experiment_ID=experiment_id) request.dbsession.add(page) #experiment_id = request.dbsession.query(experiment).filter_by(experiment_description=experiment_description).first() next_url = request.route_url('experimentPage', experiment=experiment_id) return HTTPFound(location=next_url) except deform.ValidationFailure as e: # catch the exception return {'experimentForm':e.render()} else: experimentForm = form.render() return{'experimentForm':experimentForm}
def validate(self, controls): """ Validate the set of controls returned by a form submission against the schema associated with this field or form. ``controls`` should be a *document-ordered* sequence of two-tuples that represent the form submission data. Each two-tuple should be in the form ``(key, value)``. ``node`` should be the schema node associated with this widget. For example, using WebOb, you can compute a suitable value for ``controls`` via:: request.POST.items() Or, if you're using a ``cgi.FieldStorage`` object named ``fs``, you can compute a suitable value for ``controls`` via:: controls = [] if fs.list: for control in fs.list: if control.filename: controls.append((control.name, control)) else: controls.append((control.name, control.value)) Equivalent ways of computing ``controls`` should be available to any web framework. When the ``validate`` method is called: - if the fields are successfully validated, a data structure represented by the deserialization of the data as per the schema is returned. It will be a mapping. - If the fields cannot be successfully validated, a :exc:`colander.Invalid` exception is raised. The typical usage of ``validate`` in the wild is often something like this (at least in terms of code found within the body of a :mod:`pyramid` view function, the particulars will differ in your web framework):: from webob.exc import HTTPFound from deform.exception import ValidationFailure from deform import schema from deform.form import Form from my_application import do_something class MySchema(schema.MappingSchema): color = schema.SchemaNode(schema.String()) schema = MySchema() form = Form(schema) if 'submit' in request.POST: # the form submission needs validation controls = request.POST.items() try: deserialized = form.validate(controls) do_something(deserialized) return HTTPFound(location='http://example.com/success') except ValidationFailure, e: return {'form':e.render()} else: return {'form':form.render()} # the form just needs rendering """ pstruct = peppercorn.parse(controls) e = None try: cstruct = self.deserialize(pstruct) except colander.Invalid, e: # fill in errors raised by widgets self.widget.handle_error(self, e) cstruct = e.value
def validate(self, controls, subcontrol=None): """ Validate the set of controls returned by a form submission against the schema associated with this field or form. ``controls`` should be a *document-ordered* sequence of two-tuples that represent the form submission data. Each two-tuple should be in the form ``(key, value)``. ``node`` should be the schema node associated with this widget. For example, using WebOb, you can compute a suitable value for ``controls`` via:: request.POST.items() Or, if you're using a ``cgi.FieldStorage`` object named ``fs``, you can compute a suitable value for ``controls`` via:: controls = [] if fs.list: for control in fs.list: if control.filename: controls.append((control.name, control)) else: controls.append((control.name, control.value)) Equivalent ways of computing ``controls`` should be available to any web framework. When the ``validate`` method is called: - if the fields are successfully validated, a data structure represented by the deserialization of the data as per the schema is returned. It will be a mapping. - If the fields cannot be successfully validated, a :exc:`deform.exception.ValidationFailure` exception is raised. The typical usage of ``validate`` in the wild is often something like this (at least in terms of code found within the body of a :mod:`pyramid` view function, the particulars will differ in your web framework):: from webob.exc import HTTPFound from deform.exception import ValidationFailure from deform import Form import colander from my_application import do_something class MySchema(colander.MappingSchema): color = colander.SchemaNode(colander.String()) schema = MySchema() def view(request): form = Form(schema, buttons=('submit',)) if 'submit' in request.POST: # form submission needs validation controls = request.POST.items() try: deserialized = form.validate(controls) do_something(deserialized) return HTTPFound(location='http://example.com/success') except ValidationFailure as e: return {'form':e.render()} else: return {'form':form.render()} # the form just needs rendering .. warning:: ``form.validate(controls)`` mutates the ``form`` instance, so the ``form`` instance should be constructed (and live) inside one request. If ``subcontrol`` is supplied, it represents a named subitem in the data returned by ``peppercorn.parse(controls)``. Use this subitem as the pstruct to validate instead of using the entire result of ``peppercorn.parse(controls)`` as the pstruct to validate. For example, if you've embedded a mapping in the form named ``user``, and you want to validate only the data contained in that mapping instead if all of the data in the form post, you might use ``form.validate(controls, subcontrol='user')``. """ try: pstruct = peppercorn.parse(controls) except ValueError as e: exc = colander.Invalid(self.schema, "Invalid peppercorn controls: %s" % e) self.widget.handle_error(self, exc) cstruct = colander.null raise exception.ValidationFailure(self, cstruct, exc) if subcontrol is not None: pstruct = pstruct.get(subcontrol, colander.null) return self.validate_pstruct(pstruct)
def spectraForm(request): """ project form page """ tmpstore = FileUploadTempStore() class Sample(colander.MappingSchema): setup_schema(None, spectra) spectraSchema = spectra.__colanderalchemy__ type = colander.SchemaNode( colander.String(), default='', widget=deform.widget.SelectWidget(values=type_choices)) format = colander.SchemaNode( colander.String(), default='', widget=deform.widget.SelectWidget(values=format_choices)) sample_power_spectrum = colander.SchemaNode( deform.FileData(), widget=deform.widget.FileUploadWidget(tmpstore)) background_power_spectrum = colander.SchemaNode( deform.FileData(), widget=deform.widget.FileUploadWidget(tmpstore)) initial_result_spectrum = colander.SchemaNode( deform.FileData(), widget=deform.widget.FileUploadWidget(tmpstore)) final_spectrum = colander.SchemaNode( deform.FileData(), widget=deform.widget.FileUploadWidget(tmpstore)) setup_schema(None, post_processing_and_deposited_spectra) ppSchema = post_processing_and_deposited_spectra.__colanderalchemy__ upload = colander.SchemaNode( deform.FileData(), widget=deform.widget.FileUploadWidget(tmpstore)) form = Sample() form = deform.Form(form, buttons=('submit', )) if 'submit' in request.POST: #add more of these and then work on jcamp graph overlays with javascript try: #appstruct = form.validate(controls) #call validate #upload file functionality - sample_power_spectrum as initial example print(request.POST) controls = request.POST.items() pstruct = peppercorn.parse(controls) print(pstruct) """ this doesnt work for now dirName = request.params['experiment_ID'] dirName = 'C:/ftirdb/ftirdb/data/' + dirName os.mkdir(dirName)""" myfile = pstruct['sample_power_spectrum']['upload'] background = pstruct['background_power_spectrum']['upload'] init = pstruct['initial_result_spectrum']['upload'] final = pstruct['final_spectrum']['upload'] #using pure path as coding on windows and putting on to a linux server permanent_store = pathlib.PureWindowsPath( 'C:/ftirdb/ftirdb/static/data') permanent_file = open( os.path.join(permanent_store, myfile.filename.lstrip(os.sep)), 'wb') shutil.copyfileobj(myfile.file, permanent_file) myfile.file.close() permanent_file.close() permanent_file = open( os.path.join(permanent_store, background.filename.lstrip(os.sep)), 'wb') shutil.copyfileobj(background.file, permanent_file) background.file.close() permanent_file.close() permanent_file = open( os.path.join(permanent_store, init.filename.lstrip(os.sep)), 'wb') shutil.copyfileobj(init.file, permanent_file) init.file.close() permanent_file.close() permanent_file = open( os.path.join(permanent_store, final.filename.lstrip(os.sep)), 'wb') shutil.copyfileobj(final.file, permanent_file) final.file.close() permanent_file.close() print(myfile.filename) #break through adding schema to db without having to manually enter each one ok = pstruct['spectraSchema'] type = request.params['type'] format = request.params['format'] page = spectra(**ok, spectra_type=type, format=format) request.dbsession.add(page) #try the same for upload and file name to add to db pok = pstruct['ppSchema'] sample_power_spectrum = myfile.filename background_power_spectrum = background.filename initial = init.filename final = final.filename searchdb = request.dbsession.query(spectra).order_by( spectra.spectra_ID.desc()).first() spectra_ID = searchdb.spectra_ID print(spectra_ID) page = post_processing_and_deposited_spectra( spectra_ID=spectra_ID, final_published_spectrum=final, sample_power_spectrum=sample_power_spectrum, background_power_spectrum=background_power_spectrum, initial_result_spectrum=initial, **pok) request.dbsession.add(page) #in future change this so it just querys spectra and takes the first option next_url = request.route_url('spectraPage', spectra_ID=spectra_ID) return HTTPFound(location=next_url) except deform.ValidationFailure as e: # catch the exception return {'spectraForm': e.render()} else: spectraForm = form.render() return {'spectraForm': spectraForm}
return {'main':main, 'messages':messages, 'form':myform.render(),'logged_in':logged_in, 'actions':actions} @view_config(route_name='signup', renderer='templates/justforms.pt') def signup(request): """Sign up form page """ schema = SignupSchema() myform = Form(schema, buttons=('submit',)) came_from = request.params.get('came_from', '/') main = get_renderer('templates/unlogged.pt').implementation() logged_in = authenticated_userid(request) if 'submit' in request.POST or 'Submit' in request.POST: controls = request.POST.items() params = peppercorn.parse(request.POST.items()) username = params['username'] #validate form try: myform.validate(controls) except ValidationFailure, e: return {'main':main, 'form':e.render(), 'logged_in':logged_in} login = username firstname = params['firstname'] lastname = params['lastname'] password = _hash_pw(params['password']['value']) email = params['email'] gender = params['gender'] lookingfor = params['lookingfor']
def spectrometerForm(request): """ project form page """ tmpstore = FileUploadTempStore() exp = request.matchdict['experiment_ID'] class Sample(colander.MappingSchema): setup_schema(None, spectrometer) spectrometerSchema = spectrometer.__colanderalchemy__ light_source = colander.SchemaNode( colander.String(), default='', widget=deform.widget.SelectWidget(values=light_source_choice)) beamsplitter = colander.SchemaNode( colander.String(), default='', widget=deform.widget.SelectWidget(values=beam_splitter_choice)) detector = colander.SchemaNode( colander.String(), default='', widget=deform.widget.SelectWidget(values=detector_choice)) optics = colander.SchemaNode( colander.String(), default='', widget=deform.widget.SelectWidget(values=optics_choice)) type_of_recording = colander.SchemaNode( colander.String(), default='', widget=deform.widget.SelectWidget(values=recording_choice)) mode_of_recording = colander.SchemaNode( colander.String(), default='', widget=deform.widget.SelectWidget(values=mode_choice)) setup_schema(None, atr) atrSchema = atr.__colanderalchemy__ prism = colander.SchemaNode( colander.String(), default='', widget=deform.widget.SelectWidget(values=prism_choice)) setup_schema(None, not_atr) not_atrSchema = not_atr.__colanderalchemy__ window = colander.SchemaNode( colander.String(), default='', widget=deform.widget.SelectWidget(values=window_choice)) setup_schema(None, transflectance_diffuse) trans_diff_Schema = transflectance_diffuse.__colanderalchemy__ form = Sample() form = deform.Form(form, buttons=('submit', )) if 'submit' in request.POST: # controls = request.POST.items() try: #upload file functionality - sample_power_spectrum as initial example print(controls) appstruct = form.validate(controls) pstruct = peppercorn.parse(controls) print(pstruct) optics = request.params['optics'] beamsplitter = request.params['beamsplitter'] type_of_recording = request.params['type_of_recording'] mode_of_recording = request.params['mode_of_recording'] detector = request.params['detector'] light_source = request.params['light_source'] prism = request.params['prism'] window = request.params['window'] #break through adding schema to db without having to manually enter each one """ok = pstruct['Spectrometerschema'] page = spectrometer(experiment_ID=exp,optics=optics,beamsplitter=beamsplitter,type_of_recording=type_of_recording, detector__type=detector,light_source=light_source,mode_of_recording=mode_of_recording,**ok) request.dbsession.add(page) #try the same for upload and file name to add to db pok = pstruct['atrSchema'] page = atr(**pok,prism_material=prism) request.dbsession.add(page) naok = pstruct['not_atrSchema'] page = not_atr(**naok,sample_window_material=window) request.dbsession.add(page) tran = pstruct['trans_diff_Schema'] page = transflectance_diffuse(**tran) request.dbsession.add(page) appstruct = form.validate(controls) #call validate #need to fix this print(appstruct) experiment_id = request.dbsession.query(spectrometer).filter_by(optics=optics).first() spec_id = experiment_id.spectrometer_ID""" next_url = request.route_url('spectrometerPage', spectrometer_ID=1) return HTTPFound(location=next_url) except deform.ValidationFailure as e: # catch the exception return {'spectrometerForm': e.render()} else: spectrometerForm = form.render() return {'spectrometerForm': spectrometerForm}
def _callFUT(self, fields): from peppercorn import parse return parse(fields)
def _reverse(self, fields): from peppercorn import parse return parse(fields)
def validate(self, controls): """ Validate the set of controls returned by a form submission against the schema associated with this field or form. ``controls`` should be a *document-ordered* sequence of two-tuples that represent the form submission data. Each two-tuple should be in the form ``(key, value)``. ``node`` should be the schema node associated with this widget. For example, using WebOb, you can compute a suitable value for ``controls`` via:: request.POST.items() Or, if you're using a ``cgi.FieldStorage`` object named ``fs``, you can compute a suitable value for ``controls`` via:: controls = [] if fs.list: for control in fs.list: if control.filename: controls.append((control.name, control)) else: controls.append((control.name, control.value)) Equivalent ways of computing ``controls`` should be available to any web framework. When the ``validate`` method is called: - if the fields are successfully validated, a data structure represented by the deserialization of the data as per the schema is returned. It will be a mapping. - If the fields cannot be successfully validated, a :exc:`deform.exception.ValidationFailure` exception is raised. The typical usage of ``validate`` in the wild is often something like this (at least in terms of code found within the body of a :mod:`pyramid` view function, the particulars will differ in your web framework):: from webob.exc import HTTPFound from deform.exception import ValidationFailure from deform import schema from deform.form import Form from my_application import do_something class MySchema(schema.MappingSchema): color = schema.SchemaNode(schema.String()) schema = MySchema() form = Form(schema) if 'submit' in request.POST: # the form submission needs validation controls = request.POST.items() try: deserialized = form.validate(controls) do_something(deserialized) return HTTPFound(location='http://example.com/success') except ValidationFailure, e: return {'form':e.render()} else: return {'form':form.render()} # the form just needs rendering """ pstruct = peppercorn.parse(controls) exc = None try: cstruct = self.deserialize(pstruct) except colander.Invalid as e: # fill in errors raised by widgets self.widget.handle_error(self, e) cstruct = e.value exc = e try: appstruct = self.schema.deserialize(cstruct) except colander.Invalid as e: # fill in errors raised by schema nodes self.widget.handle_error(self, e) exc = e if exc: raise exception.ValidationFailure(self, cstruct, exc) return appstruct