Ok, will try a more concrete example, and I'll start by showing what I used
to have :
In *MODELS/MODELS.PY *:
db.define_table('modelA ',
Field('modelA_field1','string),
Field('modelA_field2','string),
)
db.define_table('modelB ',
Field('modelB_field1','string),
Field('modelB_field2','string),
)
In *CONTROLLERS/DEFAULT.PY* :
def modelA_read():
# I do all work here, in regard to generate forms, pagination,
etc...
return dict(read_form_for_modelA)
def modelB_read():
# Do all work here, in regard to generate forms, pagination,
etc...
return dict(read_form_for_modelB)
def modelA_edit():
# Do all work here, in regard to generate forms, etc...
return dict(edit_form_for_modelA)
def modelB_edit():
# Do all work here, in regard to generate forms, etc...
return dict(edit_form_for_modelB)
In *VIEWS/DEFAULT/MODELA_READ.HTML*.
>
> {{extend 'layout.html'}}
> <!-- I do all representation of read form for ModelA-->
In *VIEWS/DEFAULT/MODELB_READ.HTML*.
>
> {{extend 'layout.html'}}
> <!-- I do all representation of read form for ModelB-->
In *VIEWS/DEFAULT/MODELA_EDIT.HTML*.
>
> {{extend 'layout.html'}}
> <!-- I do all representation of edit form for ModelA-->
In *VIEWS/DEFAULT/MODELB_EDIT.HTML*.
>
> {{extend 'layout.html'}}
> <!-- I do all representation of edit form for ModelB-->
Most of the work done inside the controllers (modelA_read/modelB_read and
modelA_edit/modelB_edit), and inside the views
(modelA_read.html/modelB_read.html and modelA_edit.html/modelB_edit.html),
was basically the same.
So now I have :
In *MODELS/MODELS.PY *(Nothing changed here) :
db.define_table('modelA ',
Field('modelA_field1','string),
Field('modelA_field2','string),
)
db.define_table('modelB ',
Field('modelB_field1','string),
Field('modelB_field2','string),
)
In *MODELS/GENERIC.PY* :
def generic_read():
# Do all work here, get mydata, generate forms, pagination,
etc...
return dict(read_form_for_whatever_model)
def generic_edit():
# Do all work here, get mydata, generate forms, pagination,
etc...
return dict(edit_form_for_whatever_model)
In *CONTROLLERS/DEFAULT.PY* :
def modelA_read():
# I do nothing here
return generic_read()
def modelB_read():
# I do nothing here
return generic_read()
def modelA_edit():
# I do nothing here
return generic_edit()
def modelB_edit():
# I do nothing here
return generic_edit()
In *VIEWS/DEFAULT/MODELA_READ.HTML*.
>
> {{extend 'generic_read.html'}} # I do nothing else here either
In *VIEWS/DEFAULT/MODELB_READ.HTML*.
>
> {{extend 'generic_read.html'}} # I do nothing else here either
In *VIEWS/DEFAULT/MODELA_EDIT.HTML*.
>
> {{extend 'generic_edit.html'}} # I do nothing else here either
In *VIEWS/DEFAULT/MODELB_EDIT.HTML*.
>
> {{extend 'generic_edit.html'}} # I do nothing else here either
In *VIEWS/GENERIC_READ.HTML*
> {{extend 'layout.html'}}
> {{include}}
> <!-- Do all representation of my read form, for whatever model -->
>
In *VIEWS/GENERIC_EDIT.HTML*
> {{extend 'layout.html'}}
> {{include}}
> <!-- Do all representation of my edit form, for whatever model -->
So, my question was about how to get rid of these lines on DEFAULT.PY :
def modelfoo_read():
# I do nothing here
return generic_read()
... and also avoid having to create views for each of those controllers,
where I only have one line of code :
{{extend 'generic_read.html'}}
I'm trying your solution with response.view, and it seems ok so far, but
I'll give you final feedback...
On Monday, October 15, 2012 3:33:14 PM UTC+1, apinho wrote:
>
> Hi,
>
> I started with web2py a few weeks ago, writing some very simple apps. I
> noticed that I was constantly repeating myself in the following steps :
> Write a controller to fetch the data
> Write a view to present data.
>
> So, I made generic controllers and views, which I later call using this
> schema :
>
> User request : http://myserver/myapp/mymodel_list
>
> In CONTROLLERS/DEFAULT.PY :
> def mymodel_list():
> return generic_list()
>
> In MODELS/GENERIC.PY :
> def generic_list():
> # Do all work here, get mydata, pagination, etc...
> return dict(mydata)
>
> In VIEWS/DEFAULT/MYMODEL_LIST.HTML :
> {{extend 'generic_list.html'}}
>
> In VIEWS/GENERIC_LIST.HTML
> {{extend 'layout.html'}}
> {{include}}
> <!-- Do all representation of mydata -->
>
> This works well for me, cause I only have to deal with 4/5 controller and
> views (generic_list, generic_read, generic_add, generic_edit).
>
> One question though :
> For every model I have to create all the functions :
> def mymodel_read():
> return generic_read()
> def mymodel_list():
> return generic_list()
> etc...
> .. and I also have to create all the views :
> mymodel_list.html :
> {{extend 'generic_list'}}
> mymodel_list.read :
> {{extend 'generic_read'}}
> ...etc
>
> I believe there must be a way to avoid creating these views and these
> controllers, through the use of routes, or something.
>
> Someone care to guide me to do this ?
>
>
>
>
>
>
--
