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 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 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 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 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 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 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='sobolevn').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 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 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 _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 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 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 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 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 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 __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 ModelForm(model, db_session, exclude=None):
    return model_form(
        model=model,
        db_session=db_session,
        base_class=Form,
        exclude_fk=False,
        exclude=exclude
        )