def get(self,item_id=None): from auth.models import User if 'page' in request.endpoint: from page.models import Page page = Page.get_by_id(item_id) if not 'content' in request.endpoint: self._form = model_form(Page,Page.session,base_class=Form,exclude=['added_by','date_added']) self._context['obj'] = page else: from page.forms import EditContentForm self._form = EditContentForm self._form_obj = page elif 'block' in request.endpoint: from page.models import Block block = Block.get_by_id(item_id) if not 'content' in request.endpoint: self._form = model_form(Block,Block.session,base_class=Form,exclude=['templates','pages']) self._context['obj'] = block else: from page.forms import EditContentForm self._form = EditContentForm self._form_obj = block else: from admin.forms import TemplateBodyFieldForm from wtforms import FormField from page.models import Template template = Template.get_by_id(item_id) form = model_form(Template,Template.session,base_class=Form,exclude=['pages','blocks','filename','body']) class TemplateForm(form): body = FormField(TemplateBodyFieldForm,separator='_') self._form = TemplateForm self._context['obj'] = template self._form_obj = template return self.render()
def edit(model_name, model_key): """ Edit a particular instance of a model. """ if not model_name in model_dict.keys(): return "%s cannot be accessed through this admin page" % ( model_name,) model = model_dict[model_name] model_form = admin_blueprint.form_dict[model_name] pk = _get_pk_name(model) pk_query_dict = {pk: model_key} try: model_instance = db_session.query(model).filter_by( **pk_query_dict).one() except NoResultFound: return "%s not found: %s" % (model_name, model_key) if request.method == 'GET': form = model_form(obj=model_instance) has_file_field = filter(lambda field: isinstance(field, wtf_fields.FileField), form) return render_template( 'admin/edit.html', admin_models=sorted(model_dict.keys()), model_instance=model_instance, model_name=model_name, form=form, has_file_field=has_file_field) elif request.method == 'POST': form = model_form(request.form, obj=model_instance) has_file_field = filter(lambda field: isinstance(field, wtf_fields.FileField), form) if form.validate(): model_instance = _populate_model_from_form( model_instance, form) db_session.add(model_instance) db_session.commit() flash('%s updated: %s' % (model_name, model_instance), 'success') return redirect( url_for('.list_view', model_name=model_name)) else: flash('There was an error processing your form. ' 'This %s has not been saved.' % model_name, 'error') return render_template( 'admin/edit.html', admin_models=sorted(model_dict.keys()), model_instance=model_instance, model_name=model_name, form=form, has_file_field=has_file_field)
def client_sensor_edit(client_id, sensor_id): with app.db.session_scope(): sensor = app.db.get_sensor(sensor_id) MyForm = model_form(Sensor, \ base_class=Form, \ db_session=app.db.get_session(), exclude=['core_device', 'name', 'reference', 'incremental', 'formula', 'data_type', 'conversion', 'last_value', 'last_received', 'history_duplicate','value_min','value_max']) #MyForm.history_duplicate.kwargs['validators'] = [] MyForm.history_store.kwargs['validators'] = [] form = MyForm(request.form, sensor) if request.method == 'POST' and form.validate(): if request.form['history_store'] == 'y': store = 1 else: store = 0 app.db.update_sensor(sensor_id, \ history_round=request.form['history_round'], \ history_store=store, \ history_max=request.form['history_max'], \ history_expire=request.form['history_expire'], timeout=request.form['timeout']) flash(gettext("Changes saved"), "success") return redirect("/client/{0}/dmg_devices/known".format(client_id)) pass else: return render_template('client_sensor.html', form = form, clientid = client_id, mactive="clients", active = 'devices' )
def form_for(model_class, timestamp_mixin=True, exclude=None, skip=[]): if timestamp_mixin and exclude: exclude = exclude + ['created_on','created_by','creator_id','updated_on','updated_by','updater_id'] elif timestamp_mixin and not exclude: exclude = ['created_on','created_by','creator_id','updated_on','updated_by','updater_id'] form_model_base = model_form(model_class, Form, exclude=exclude, converter=CrudModelConverter()) def _populate_obj(self, obj): skip_fields = ['UploadImageField','UploadField','FieldList'] for name, field in self._fields.iteritems(): if not name in self.skip and not type(field).__name__ in skip_fields: field.populate_obj(obj, name) def _pre_process_content(self): pass Frm = type("CrudExtraBaseForm", (form_model_base,), { 'source_class' : model_class, 'skip': skip, 'populate_obj': _populate_obj, 'pre_process_content': _pre_process_content, }) return Frm
def getform(request, sub_id, domain): """ Returns a metadata form tailored to the given domain. """ domain = domain.lower() if domain in metadata_classes(): meta = metadata_classes()[domain]() else: from b2share_model.model import SubmissionMetadata meta = SubmissionMetadata() if not is_current_user_allowed_to_deposit(meta): return render_template('b2share-addmeta-table-denied.html') MetaForm = model_form(meta.__class__, base_class=FormWithKey, exclude=['submission', 'submission_type'], field_args=meta.field_args, converter=HTML5ModelConverter()) meta_form = MetaForm(request.form, meta) return render_template( 'b2share-addmeta-table.html', sub_id=sub_id, metadata=meta, form=meta_form, getattr=getattr)
def persons_edit(person_id): with app.db.session_scope(): if person_id > 0: person = app.db.get_person(person_id) else: personn = None MyForm = model_form(Person, \ base_class=Form, \ db_session=app.db.get_session(), exclude=['user_accounts']) form = MyForm(request.form, person) if request.method == 'POST' and form.validate(): if int(person_id) > 0: app.db.update_person(person_id, \ p_first_name=request.form['first_name'], \ p_last_name=request.form['last_name'], \ p_birthdate=request.form['birthdate']) else: app.db.add_person(\ p_first_name=request.form['first_name'], \ p_last_name=request.form['last_name'], \ p_birthdate=request.form['birthdate']) flash(gettext("Changes saved"), "success") return redirect("/persons") pass elif request.method == 'POST' and not form.validate(): flash(gettext("Invalid input"), "error") return render_template('person_edit.html', form = form, personid = person_id, mactve="auth", )
def index(): """ Generates the main page and the automatic form using a generic AppItem object :return: the template to be served to the client """ params = {'title': 'Main'} app_item = AppItem() # crates a model class from the application item app_item_form = model_form(AppItem, db.session, base_class=Form, field_args=app_item.field_args) login_form = LoginForm(request.form) if helpers.validate_form_on_submit(login_form): user = login_form.get_user() login.login_user(user) params['retry_login'] = False # redirect to prevent form double submit return redirect(request.url) else: if login_form.errors: params['retry_login'] = True params['is_authenticated'] = login.current_user.is_authenticated() check_errors() return render_template('index.html', params=params, form=app_item_form(obj=app_item), login_form=login_form, app_config=ActiveConfig)
class LoginForm(model_form(User, base_class=Form, exclude=['first_name', 'last_name'], field_args=User.get_field_args_login())): """ Class representing the form handling authentication in the admin area. """ def validate_username(self, field): del field user = self.get_user() if user is None: raise validators.ValidationError('Username does not exist.') def validate_password(self, field): del field user = self.get_user() if user is None: return if not check_password_hash(user.password, self.password.data): raise validators.ValidationError('Password is invalid.') def get_user(self): return User.query.filter_by(username=self.username.data).first()
def index(): from models import User, Post post_form_class = model_form(Post, base_class=Form, db_session=db.session) if request.method == 'POST': # For full example: # http://flask.pocoo.org/snippets/60/ # alternative: # https://wtforms-alchemy.readthedocs.org/en/latest/introduction.html user = User.query.filter_by(username='******').first() print("{} is creating a new {}'th post!".format( user.username, len(user.posts.all()) + 1)) form = post_form_class(request.form) if form.validate(): post = Post(**form.data) db.session.add(post) db.session.commit() flash('Post created!') else: flash('Form is not valid! Post was not created.') else: form = post_form_class() posts = Post.query.all() return render_template('home.html', form=form, posts=posts)
def get_form(self, adding=False): return model_form(self.model, base_class=BaseForm, only=self.only, exclude=self.exclude, field_args=self.field_args, converter=AdminModelConverter(self))
def user(id=0): user = User.query.get(id) form = model_form(User, base_class=Form, db_session=db.session, # автоматическая генерация класса формы field_args = dict([(c.name, {'label': c.doc}) for c in User.__table__.columns if c.doc ], exclude = ['groups']))(request.form, obj = user) if request.method == 'POST' and form.validate_on_submit(): if user: user.login=form.login.data user.uid=form.uid.data user.status=form.status.data user.email=form.email.data user.password=form.password.data user.first_login=form.first_login.data user.last_login=form.last_login.data user.cdate=form.cdate.data db.session.commit() else: user = User(request.form['login'] , request.form['password'], email=request.form['email']) db.session.add(user) db.session.commit() return redirect(url_for('index')) flash(u'Выбран id: %s' % id) return render_template('edit.html', form=form)
def get_form(self, adding=False): return model_form(self.model, BaseForm, only=self.only, exclude=self.exclude, field_args=self.field_args, converter=AdminModelConverter(self))
def home(): from models import User user_form_class = model_form(User, base_class=FlaskForm, db_session=db.session) if request.method == 'POST': form = user_form_class(request.form) if form.validate(): try: model = User(**form.data) db.session.add(model) db.session.commit() flash('User created!') return redirect(url_for('home')) except IntegrityError: db.session.rollback() flash('This user is already exist') except Exception as ex: logger.error(ex) db.session.rollback() flash('Cant save user: '******'Someone have submitted an incorrect form!') flash('Invalid form. Please check fields') else: form = user_form_class() age18 = datetime.now() - timedelta(days=365.25 * 18) users = User.query.filter(User.birthday < age18) return render_template( 'home.html', form=form, items=users, )
def get(self, obj_id='', operation='', filter_name=''): if operation == 'new': # we just want an empty form form = self.ObjForm() action = self.path return self.render_edit(form=form, action=action) if operation == 'delete': obj = self.model.query.get(obj_id) db.session.delete(obj) db.session.commit() return redirect(self.path) if obj_id: #Dynamically create form fields based on db Model ObjForm = model_form(self.model, db.session) obj = self.model.query.get(obj_id) #populate form form = self.ObjForm(obj=obj) # action is the url that we will later use to POST data action = request.path return self.render_edit(form=form, action=action) obj = self.model.query.order_by(self.model.date_Created.desc()).all() #choosing which template to display if self.path == "/refineryApp/": return self.render_refineryApp(obj=obj) elif "Category" in str(obj): return self.render_Category(obj=obj) elif "Workflow" in str(obj): return self.render_Workflows(obj=obj)
def client_sensor_edit(client_id, sensor_id): with app.db.session_scope(): sensor = app.db.get_sensor(sensor_id) MyForm = model_form(Sensor, \ base_class=Form, \ db_session=app.db.get_session(), exclude=['core_device', 'name', 'reference', 'incremental', 'formula', 'data_type', 'conversion', 'last_value', 'last_received', 'history_duplicate']) #MyForm.history_duplicate.kwargs['validators'] = [] MyForm.history_store.kwargs['validators'] = [] form = MyForm(request.form, sensor) if request.method == 'POST' and form.validate(): if request.form['history_store'] == 'y': store = 1 else: store = 0 app.db.update_sensor(sensor_id, \ history_round=request.form['history_round'], \ history_store=store, \ history_max=request.form['history_max'], \ history_expire=request.form['history_expire']) flash(gettext("Changes saved"), "success") return redirect("/client/{0}/devices/known".format(client_id)) pass else: return render_template('client_sensor.html', form=form, clientid=client_id, mactve="clients", active='devices')
def create_or_update_model(kls, base_object=None, supplied_data=None): # TODO: I don't like the "error" here... # Create a form based upon the SQLAlchemy model model = kls() if not base_object else base_object if hasattr(kls, "Form"): # If the class has a handmade WTForm built, use that for validation MyForm = kls.Form else: # Otherwise generate the form dynamically MyForm = model_form(kls, wtf.Form) if supplied_data: data = MultiDict(supplied_data) else: data = flask.request.form form = MyForm(data, model) # Ensure it is a POST/PUT or data supplied by another function if flask.request.method in ["POST", "PUT"] or supplied_data: # If there are issues, note them, otherwise create/update the model if form.validate(): try: form.populate_obj(model) db.session.add(model) db.session.commit() return dict(model=model, success=True) except SQLAlchemyError, e: if app.debug: # If we're in debug mode, re-raise so we get the debugger raise e else: # If in production ... uh-oh # TODO: Push over to a 500? flask.flash("Database error...", "alert-error")
def test_no_mro(self): converter = ModelConverter(use_mro=False) # Without MRO, will not be able to convert 'grade' self.assertRaises(ModelConversionError, model_form, self.Course, self.sess, converter=converter) # If we exclude 'grade' everything should continue working F = model_form(self.Course, self.sess, exclude=['grade'], converter=converter) self.assertEqual(len(list(F())), 7)
def edit(request): """ edit(request) no return value, called with route_url('apex_edit', request) This function will only work if you have set apex.auth_profile. This is a very simple edit function it works off your auth_profile class, all columns inside your auth_profile class will be rendered. """ title = _('Edit') ProfileForm = model_form( model=get_module(apex_settings('auth_profile')), base_class=ExtendedForm, exclude=('id', 'user_id'), ) record = AuthUser.get_profile(request) form = ProfileForm(obj=record) if request.method == 'POST' and form.validate(): record = merge_session_with_post(record, request.POST.items()) DBSession.merge(record) DBSession.flush() flash(_('Profile Updated')) return HTTPFound(location=request.url) return {'title': title, 'form': form, 'action': 'edit'}
def getform(request, sub_id, domain): """ Returns a metadata form tailored to the given domain. """ domain = domain.lower() if domain in metadata_classes(): meta = metadata_classes()[domain]() else: from b2share_model.model import SubmissionMetadata meta = SubmissionMetadata() if not is_current_user_allowed_to_deposit(meta): return render_template('b2share-addmeta-table-denied.html') MetaForm = model_form(meta.__class__, base_class=FormWithKey, exclude=['submission', 'submission_type'], field_args=meta.field_args, converter=HTML5ModelConverter()) meta_form = MetaForm(request.form, meta) return render_template('b2share-addmeta-table.html', sub_id=sub_id, metadata=meta, form=meta_form, getattr=getattr)
def post(self, item_id=None): from page.models import StaticBlock form = model_form(StaticBlock, StaticBlock.session, base_class=Form, exclude=['content']) class StaticBlockForm(form): content = FormField(TextEditorFieldForm, '_') self._form = StaticBlockForm if item_id is None: block = StaticBlock() msg = "created a new" else: block = StaticBlock.get_by_id(item_id) msg = "updated a" data = self.get_form_data() block.name = data['name'] block.content = data['content']['content'] block.block_id = data['block_id'] if block.save(): flash(msg + " static_block with id: {}".format(block.block_id)) return self.redirect('admin.index') else: flash("Error") return self.render()
def posts_of_user(): posts = Post.query.all() if not current_user.is_authenticated: return render_template('posts.html', posts=posts) else: post_form_class = model_form(Post, base_class=Form, db_session=db.session) if request.method == 'POST': print("{} is creating a new {}'th post!".format( current_user.username, len(current_user.posts.all()) + 1)) form = post_form_class(request.form) if form.validate(): if request.form['submit'] == 'DELETE': post_to_delete = Post.query.filter_by(id=str(request.form['menu'])).first() db.session.delete(post_to_delete) db.session.commit() flash('Post deleted!') pass elif request.form['submit'] == 'Submit': post = Post(user=current_user, title=form.data['title'], content=form.data['content']) db.session.add(post) db.session.commit() flash('Post created!') else: flash('Form is not valid! Post was not created.') else: form = post_form_class() return render_template('home.html', form=form, posts=posts)
def edit(request): """ edit(request) no return value, called with route_url('apex_edit', request) This function will only work if you have set apex.auth_profile. This is a very simple edit function it works off your auth_profile class, all columns inside your auth_profile class will be rendered. """ title = _('Edit') ProfileForm = model_form( model=get_module(apex_settings('auth_profile')), base_class=ExtendedForm, exclude=('id', 'user_id'), ) record = AuthUser.get_profile(request) form = ProfileForm(obj=record) if request.method == 'POST' and form.validate(): record = merge_session_with_post(record, request.POST.items()) DBSession.merge(record) DBSession.flush() flash(_('Profile Updated')) return HTTPFound(location=request.url) return {'title': title, 'form': form, 'action': 'edit'}
def index(): from models import User, Post post_form_class = model_form(Post, base_class=Form, db_session=db.session) if request.method == 'POST': # For full example: # http://flask.pocoo.org/snippets/60/ # alternative: # https://wtforms-alchemy.readthedocs.org/en/latest/introduction.html user = User.query.filter_by(username='******').first() print("{} is creating a new {}'th post!".format( user.username, len(user.posts.all()) + 1)) form = post_form_class(request.form) if form.validate(): post = Post(**form.data) db.session.add(post) db.session.commit() flash('Post created!') else: flash('Form is not valid! Post was not created.') else: form = post_form_class() posts = Post.query.all() return render_template('home.html', form=form, posts=posts)
def post(self,item_id=None): from ext import db from auth.models import User if 'content' in request.endpoint: session['content'] = request.form['content'][:] return self.redirect('admin.edit_{}'.format(request.url.split('/')[-3]),item_id='{}'.format(request.url.split('/')[-1])) else: if 'page' in request.endpoint: from page.models import Page as model needs_content = True msg = 'cms page' redirect = 'pages' exclude = ['added_by','date_added'] if 'block' in request.endpoint: from page.models import Block as model needs_content = True msg = 'cms block' redirect = 'blocks' exclude = ['templates','pages'] if 'template' in request.endpoint: from page.models import Template as model needs_content = False msg = 'template' redirect = 'templates' exclude = ['pages','blocks'] self._form = model_form(model,db.session,base_class=Form,exclude=exclude)(request.form) obj = model.query.filter(model.id==item_id).first() self._form.populate_obj(obj) if needs_content: if 'content' in session: obj.content = session.pop('content',None) obj.update() flash('Successfully updated {}: {}'.format(msg,obj.name)) return self.redirect('admin.{}'.format(redirect))
def post(self): from page.models import Template from auth.models import User from ext import db self._form = model_form(Template,db.session,base_class=Form,exclude=['blocks','pages','body'])(request.form) if self._form.validate(): template = Template() self._form.populate_obj(template) template.save() filename = template.filename if template.body is not None: body = template.body[:] else: body = '' from settings import BaseConfig import os templatedir = os.path.join(BaseConfig.ROOT_PATH,'templates') os.system('touch {}'.format(os.path.join(templatedir,filename))) fp = open(os.path.join(templatedir,filename),'w') fp.write(body+'\n') fp.close() flash('you have created a new template named: {}'.format(template.name)) return self.redirect('admin.templates') else: flash('You need to give the template a name') return self.render()
def post(self,item_id=None): from ext import db from auth.models import User if 'content' in request.endpoint: session['content'] = request.form['content'][:] return self.redirect('admin.edit_{}'.format(request.url.split('/')[-3]),item_id='{}'.format(request.url.split('/')[-1])) else: if 'page' in request.endpoint: from page.models import Page as model needs_content = True msg = 'cms page' redirect = 'pages' exclude = ['added_by','date_added'] if 'block' in request.endpoint: from page.models import Block as model needs_content = True msg = 'cms block' redirect = 'blocks' exclude = ['templates','pages'] if 'template' in request.endpoint: from page.models import Template as model needs_content = False msg = 'template' redirect = 'templates' exclude = ['pages','blocks'] self._form = model_form(model,db.session,base_class=Form,exclude=exclude)(request.form) obj = model.query.filter(model.id==item_id).first() self._form.populate_obj(obj) if needs_content: if 'content' in session: obj.content = session.pop('content',None) obj.update() flash('Successfully updated {}: {}'.format(msg,obj.name)) return self.redirect('admin.{}'.format(redirect))
def post(self): from page.models import Template from auth.models import User from ext import db self._form = model_form(Template,db.session,base_class=Form,exclude=['blocks','pages','body'])(request.form) if self._form.validate(): template = Template() self._form.populate_obj(template) template.save() filename = template.filename if template.body is not None: body = template.body[:] else: body = '' from settings import BaseConfig import os templatedir = os.path.join(BaseConfig.ROOT_PATH,'templates') os.system('touch {}'.format(os.path.join(templatedir,filename))) fp = open(os.path.join(templatedir,filename),'w') fp.write(body+'\n') fp.close() flash('you have created a new template named: {}'.format(template.name)) return self.redirect('admin.templates') else: flash('You need to give the template a name') return self.render()
def persons_edit(person_id): with app.db.session_scope(): if person_id > 0: person = app.db.get_person(person_id) else: personn = None MyForm = model_form(Person, \ base_class=Form, \ db_session=app.db.get_session(), exclude=['user_accounts']) form = MyForm(request.form, person) if request.method == 'POST' and form.validate(): if int(person_id) > 0: app.db.update_person(person_id, \ p_first_name=request.form['first_name'], \ p_last_name=request.form['last_name'], \ p_birthdate=request.form['birthdate']) else: app.db.add_person(\ p_first_name=request.form['first_name'], \ p_last_name=request.form['last_name'], \ p_birthdate=request.form['birthdate']) flash(gettext("Changes saved"), "success") return redirect("/persons") pass elif request.method == 'POST' and not form.validate(): flash(gettext("Invallid input"), "error") return render_template('person_edit.html', form=form, personid=person_id, mactve="auth")
def test_convert_basic(self): self.assertRaises(TypeError, model_form, None) self.assertRaises(ModelConversionError, model_form, self.Course) form_class = model_form(self.Course, exclude=['students']) form = form_class() self.assertEqual(len(list(form)), 4) assert isinstance(form.cost, fields.DecimalField)
def edit_user(username): current_app.logger.debug(f"Edit User View, user: {username}") user = User.query.filter_by(username=username).scalar() UserForm = model_form( User, db_session=db.session, base_class=FlaskForm, exclude=['password', 'created_on', 'last_login'] ) UserForm.is_admin.kwargs['validators'] = [] UserForm.is_activated.kwargs['validators'] = [] user_form = UserForm(obj=user) if user_form.validate_on_submit(): user.name = user_form.name.data user.username = user_form.username.data user.email = user_form.email.data user.is_activated = user_form.is_activated.data user.is_admin = user_form.is_admin.data user.db_commit() return redirect(url_for('admin_bp.users')) else: current_app.logger.debug(user_form.errors) return render_template( 'edit_users.html', user=user, form=user_form, title='Admin Panel - Edit User', template="admin-page", )
def get(self, obj_id='', operation='', filter_name=''): if operation == 'new': # we just want an empty form form = self.ObjForm() action = self.path return self.render_detail(form=form, action=action) if operation == 'delete': obj = self.model.query.get(obj_id) db.session.delete(obj) db.session.commit() return redirect(self.path) # list view with filter if operation == 'filter': func = self.filters.get(filter_name) obj = func(self.model) return self.render_list(obj=obj, filter_name=filter_name) if obj_id: # this creates the form fields base on the model # so we don't have to do them one by one ObjForm = model_form(self.model, db.session) obj = self.model.query.get(obj_id) # populate the form with our blog data form = self.ObjForm(obj=obj) # action is the url that we will later use # to do post, the same url with obj_id in this case action = request.path return self.render_detail(form=form, action=action) obj = self.model.query.order_by(self.model.created_on.desc()).all() return self.render_list(obj=obj)
def get(self): if not 'content' in request.endpoint: from page.models import Page from wtforms import FormField from admin.forms import BaseTemplateForm from auth.models import User from page.models import Template self._context['choices'] = [(x, x.name) for x in Template.query.all()] form = model_form(Page, Page.session, base_class=Form, exclude=['date_added', 'added_by']) class PageForm(form): template = FormField(BaseTemplateForm) def __init__(self, *args, **kwargs): if 'prefix' in kwargs: kwargs.pop('prefix') super(PageForm, self).__init__(*args, **kwargs) self._form = PageForm(prefix=False) else: from page.forms import EditContentForm from auth.models import User self._form = EditContentForm return self.render()
def index(): from models import User, Post post_form_class = model_form(Post, base_class=Form, db_session=db.session) if request.method == 'POST': form = post_form_class(request.form) if form.validate(): post = Post(**form.data) post.is_visible = True print("{} is creating a new {}'th post!".format( post.user.username, len(post.user.posts.all()) + 1)) db.session.add(post) db.session.commit() flash('Post created!') else: flash('Form is not valid! Post was not created.') else: form = post_form_class() posts = Post.query.filter_by(is_visible=True).all() return render_template('home.html', form=form, posts=posts)
def get(self, obj_id='', operation='', filter_name=''): if operation == 'new': # we just want an empty form form = self.ObjForm() action = self.path return self.render_detail(form=form, action=action) if operation == 'delete': obj = self.model.query.get(obj_id) db.session.delete(obj) db.session.commit() return redirect(self.path) # list view with filter if operation == 'filter': func = self.filters.get(filter_name) obj = func(self.model) return self.render_list(obj=obj, filter_name=filter_name) if obj_id: # this creates the form fields base on the model # so we don't have to do them one by one ObjForm = model_form(self.model, db.session) obj = self.model.query.get(obj_id) # populate the form with our blog data form = self.ObjForm(obj=obj) # action is the url that we will later use # to do post, the same url with obj_id in this case action = request.path return self.render_detail(form=form, action=action) obj = self.model.query.order_by(self.model.created_on.desc()).all() return self.render_list(obj=obj)
def client_devices_edit(client_id, did): with app.db.session_scope(): device = app.db.get_device_sql(did) MyForm = model_form(Device, \ base_class=Form, \ db_session=app.db.get_session(), exclude=['params', 'commands', 'sensors', 'address', 'xpl_commands', 'xpl_stats', 'device_type_id', 'client_id', 'client_version']) form = MyForm(request.form, device) if request.method == 'POST' and form.validate(): # save it app.db.update_device(did, \ d_name=request.form['name'], \ d_description=request.form['description'], \ d_reference=request.form['reference']) # message the suer flash(gettext("Device saved"), 'success') # reload stats req = MQSyncReq(app.zmq_context) msg = MQMessage() msg.set_action( 'reload' ) resp = req.request('xplgw', msg.get(), 100) # redirect return redirect("/client/{0}/dmg_devices/known".format(client_id)) else: return render_template('client_device_edit.html', form = form, clientid = client_id, mactive="clients", active = 'devices' )
def __init__(self, model, endpoint, Categories_template=None, Workflows_template=None, refineryApp_template=None, edit_template=None, exclude=None, filters=None): self.model = model self.endpoint = endpoint self.path = url_for('.%s' % self.endpoint) #templates based on URL if self.endpoint == "/refineryApp/category/": self.Categories_template = Categories_template if self.endpoint == "/refineryApp/workflows/": self.Workflows_template = Workflows_template if self.endpoint == "/refineryApp/": self.refineryApp_template = refineryApp_template if edit_template: self.edit_template = edit_template self.filters = filters or {} #Form will dynamically handle any db object self.ObjForm = model_form(self.model, db.session, exclude=exclude)
def _form_for_model(model_class, db_session, exclude=None, exclude_pk=True): """Return a form for a given model. This will be a form generated by wtforms.ext.sqlalchemy.model_form, but decorated with a QuerySelectField for foreign keys. """ if not exclude: exclude = [] model_mapper = sa.orm.class_mapper(model_class) relationship_fields = [] pk_names = _get_pk_names(model_class) if exclude_pk: exclude.extend(pk_names) # exclude any foreign_keys that we have relationships for; # relationships will be mapped to select fields by the # AdminConverter exclude.extend([relationship.local_side[0].name for relationship in model_mapper.iterate_properties if isinstance(relationship, sa.orm.properties.RelationshipProperty) and relationship.local_side[0].name not in pk_names]) form = model_form(model_class, exclude=exclude, converter=AdminConverter(db_session)) return form
def post(self, obj_id=''): try: # either load and object to update if obj_id is given # else initiate a new object, this will be helpfull # when we want to create a new object instead of just # editing existing one if obj_id: obj = self.model.query.get(obj_id) else: obj = self.model() ObjForm = model_form(self.model, db.session) # populate the form with the request data form = self.ObjForm(request.form) # this actually populates the obj (the blog post) # from the form, that we have populated from the request post pre_obj_dict = self._copy_obj(obj) form.populate_obj(obj) changes = self._delta(dict_pre=pre_obj_dict, obj_post=obj) db.session.add(obj) db.session.commit() # process triggers on actions initiated by user dispatcher.send(signal=Constant.SIGNAL_UI_DB_POST, model=self.model, row=obj, last_commit_field_changed_list=changes) return redirect(self.path) except AttributeError as aex: L.l.error('Error CRUD POST {}'.format(aex)) return redirect(self.path)
def client_devices_edit(client_id, did): with app.db.session_scope(): device = app.db.get_device_sql(did) MyForm = model_form(Device, \ base_class=Form, \ db_session=app.db.get_session(), exclude=['params', 'commands', 'sensors', 'address', 'xpl_commands', 'xpl_stats', 'device_type_id', 'client_id', 'client_version']) form = MyForm(request.form, device) if request.method == 'POST' and form.validate(): # save it app.db.update_device(did, \ d_name=request.form['name'], \ d_description=request.form['description'], \ d_reference=request.form['reference']) # message the suer flash(gettext("Device saved"), 'success') # reload stats req = MQSyncReq(app.zmq_context) msg = MQMessage() msg.set_action('reload') resp = req.request('xplgw', msg.get(), 100) # redirect return redirect("/client/{0}/devices/known".format(client_id)) else: return render_template('client_device_edit.html', form=form, clientid=client_id, mactve="clients", active='devices')
def get(self, item_id=None): from auth.models import User from ext import db if 'page' in request.endpoint: from page.models import Page page = Page.get_by_id(item_id) if not 'content' in request.endpoint: self._form = model_form(Page, db.session, base_class=Form, exclude=['added_by', 'date_added']) self._context['obj'] = page else: from page.forms import EditContentForm self._form = EditContentForm self._form_obj = page elif 'block' in request.endpoint: from page.models import Block block = Block.get_by_id(item_id) if not 'content' in request.endpoint: self._form = model_form(Block, db.session, base_class=Form, exclude=['templates', 'pages']) self._context['obj'] = block else: from page.forms import EditContentForm self._form = EditContentForm self._form_obj = block else: from admin.forms import TemplateBodyFieldForm from wtforms import FormField from page.models import Template template = Template.get_by_id(item_id) form = model_form(Template, db.session, base_class=Form, exclude=['pages', 'blocks', 'filename', 'body']) class TemplateForm(form): body = FormField(TemplateBodyFieldForm, separator='_') self._form = TemplateForm self._context['obj'] = template self._form_obj = template return self.render()
def ModelForm(model, db_session, exclude=None): return model_form( model=model, db_session=db_session, base_class=Form, exclude_fk=False, exclude=exclude )
def model_form(cls, *args, **kwargs): return model_form( model=cls, db_session=db.session, field_args={ 'category': {'widget': widgets.Select()} } )
def __new__(self, model_class, session, data=None, obj=None, **kwargs): FormCls = model_form( model_class, base_class=ConflictPreventionForm, only=self._editable_properties(obj, Content), db_session=session, ) return FormCls(data, obj, **kwargs)
def __new__(self, model_class, session, data=None, obj=None, **kwargs): FormCls = model_form( model_class, base_class=ConflictPreventionForm, only=self._editable_properties(obj, Content), db_session=session, ) return FormCls(data, obj, **kwargs)
def _build_form(self): """build form for model class""" exclude = self.form_exclude or [] exclude.append(get_pk_column(self.model).name) return model_form(self.model, db_session=self.session, only=self.form_only, exclude=exclude, field_args=self.form_field_args)
def addmeta(request, sub_id): """ Checks the submitted metadata form for validity. Returns a new page with success message if valid, otherwise it returns a form with the errors marked. """ if sub_id is None: #just return to deposit return redirect(url_for('.deposit')) CFG_B2SHARE_UPLOAD_FOLDER = current_app.config.get( "CFG_B2SHARE_UPLOAD_FOLDER") updir = os.path.join(CFG_B2SHARE_UPLOAD_FOLDER, sub_id) if (not os.path.isdir(updir)) or (not os.listdir(updir)): return render_template('500.html', message="Uploads not found"), 500 domain = request.form['domain'].lower() if domain in metadata_classes(): meta = metadata_classes()[domain]() else: from b2share_model.model import SubmissionMetadata meta = SubmissionMetadata() if not is_current_user_allowed_to_deposit(meta): return jsonify( valid=False, html=render_template('b2share-addmeta-table-denied.html')) MetaForm = model_form(meta.__class__, base_class=FormWithKey, exclude=['submission', 'submission_type'], field_args=meta.field_args, converter=HTML5ModelConverter()) meta_form = MetaForm(request.form, meta) if meta_form.validate_on_submit(): recid, marc = b2share_marc_handler.create_marc(request.form, sub_id, current_user['email'], meta) tmp_file = write_marc_to_temp_file(marc) # all usual tasks have priority 0; we want the bibuploads to run first from invenio.legacy.bibsched.bibtask import task_low_level_submission task_low_level_submission('bibupload', 'webdeposit', '--priority', '1', '-r', tmp_file) return jsonify(valid=True, newurl=url_for("record.metadata", recid=recid), html=render_template('record_waitforit.html', recid=recid, marc=marc)) return jsonify(valid=False, html=render_template('b2share-addmeta-table.html', sub_id=sub_id, metadata=meta, form=meta_form, getattr=getattr))
def edit_form(element): ModelForm = model_form(element.__class__, db_session=session, base_class=Form) form = ModelForm(obj=element) if fields_whitelist: form._fields = dict((k, v) for (k, v) in form._fields.items() if k in fields_whitelist) return form
def test_convert_basic(self): self.assertRaises(TypeError, model_form, None) self.assertRaises(ModelConversionError, model_form, self.Course) form_class = model_form(self.Course, exclude=['students']) form = form_class() self.assertEqual(len(list(form)), 7) assert isinstance(form.cost, fields.DecimalField) assert isinstance(form.has_prereqs, fields.BooleanField) assert isinstance(form.started, fields.DateTimeField)
class UserEditForm(model_form(User, base_class=Form, field_args=User.get_field_args_create())): """ Class representing the form handling the user editing from the admin area. """ confirm = PasswordField('Repeat Password') def get_user(self): return User.query.filter_by(username=self.username.data).first()
def model_form(cls, *args, **kwargs): return model_form( model=cls, db_session=db.session, field_args={ 'winning_level': {'widget': widgets.Select()}, 'rate': {'widget': widgets.Select()} } )
def give_form(self): """ Being called form child model class instance returns WTForms model_form object of corresponding model class. """ form = model_form((eval(type(self).__name__)), db_session) print 'in give_form', type(self).__name__ print form.data return form
def _build_form(self): """build form for model class""" exclude = self.form_exclude or [] exclude.append(get_pk_column(self.model).name) return model_form(self.model, db_session=self.session, only=self.form_only, exclude=exclude, field_args=self.form_field_args)
def create_form(element_class): ModelForm = model_form(element_class, db_session=session, base_class=Form) form = ModelForm() if fields_whitelist: form._fields = dict((k, v) for (k, v) in form._fields.items() if k in fields_whitelist) return form
def get_form(self, **kwargs): if self.wlw_model: mf = model_form(self.wlw_model, base_class = self.wlw_form, db_session = db.session, only = self.wlw_only, exclude = self.wlw_exclude, field_args = kwargs) return mf
def get_form(self, **kwargs): if self.wlw_model: mf = model_form(self.wlw_model, base_class=self.wlw_form, db_session=db.session, only=self.wlw_only, exclude=self.wlw_exclude, field_args=kwargs) return mf
def delete(post_id): from models import User, Post post_form_class = model_form(Post, base_class=Form, db_session=db.session) form = post_form_class() post = Post.query.filter_by(id=post_id).first() post.is_visible = False db.session.commit() posts = Post.query.filter_by(is_visible=True).all() return render_template('home.html', form=form, posts=posts)
def get_form(self, obj=None): """ Returns the form associated with this view if the form_class could not be found FormView tries to build the form using model_form function of wtforms sqlalchemy extension """ if self.form_class: return self.form_class(request.form, obj=obj) return model_form(self.model_class, db_session=self.db.session)( request.form, obj=obj )
def home(): if request.method == 'POST': Post.query.filter_by(id=request.form['id']).first().is_visible = False db.session.commit() print("Set invisible mark to post with id %s" %request.form['id']) post_form_class = model_form(Post, base_class=Form, db_session=db.session) form = post_form_class() posts = Post.query.filter_by(is_visible=True).all() return render_template('home.html', form=form, posts=posts)
def home(): from models import Post post_form_class = model_form( Post, base_class=FlaskForm, db_session=db.session, exclude=['time_stamp'], field_args={ 'title': { 'validators': [validators.Length(min=4, max=140)] }, 'text': { 'widget': TextArea(), 'validators': [validators.Length(min=10, max=3000)], }, 'author': { 'validators': [ validators.Length(min=3, max=100), validators.Regexp( re.compile(r'\w+\s\w+[\s\w]+', re.U), message="Type Author with format 'firstname lastname'") ] }, }) if request.method == 'POST': form = post_form_class(request.form) if form.validate(): try: model = Post(**form.data) db.session.add(model) db.session.commit() flash('Your post added!') return redirect(url_for('home')) except IntegrityError: db.session.rollback() flash('This post is already exist') except Exception as ex: logger.error(ex) db.session.rollback() flash('Cant save post: ' + str(ex)) else: logger.error('Someone have submitted an incorrect form!') flash('Invalid form. Please check fields') else: form = post_form_class() return render_template( 'home.html', form=form, items=Post.query.all(), )
def get(self): from auth.models import User from page.models import Template from wtforms import FormField from admin.forms import TemplateBodyFieldForm from ext import db AddTemplateForm = model_form(Template,db.session,base_class=Form,exclude=['blocks','pages','body']) class TemplateForm(AddTemplateForm): body = FormField(TemplateBodyFieldForm) self._form = TemplateForm return self.render()