def __call__(self, request, item_id, *args):
self._initialize(request, *args)
item = self.query.get(item_id)
if request.method == 'POST' and request.form.get('submit'):
self.session.begin()
try:
self.session.delete(item)
self.session.commit()
except IntegrityError:
self.session.rollback()
flash(request, 'notice',
'No se pudo borrar el %s %s, mas elementos dependen de el!'
% (item.__verbose_name__, unicode(item))
)
else:
return redirect('%s/../../../list' % request.base_url)
return Template('crud_delete', {
'body_class': 'crud_delete %s' % self.instance_name,
'title': self.instance_config['name'],
'subtitle': '%s %s' % (self.model.__verbose_name__, item_id),
'toolbar': self.toolbar,
'item_id': item_id,
'item': item,
'base_url': self._url,
})
def __call__(self, request, *args):
self._initialize(request, *args)
columns = self._get_model_columns()
item = None
if request.method == 'POST':
item = self._save_from_post(request, columns, self.session)
if isinstance(item, BaseResponse):
return item
relations = {}
if item and item.__load_relations_on_add__ is not None:
for key, value in item.__load_relations_on_add__.iteritems():
relations[key] = value(self.session, request)
tpl_add = Template('crud_add', {
'body_class': 'crud_add %s' % self.instance_name,
'title': self.instance_config['name'],
'subtitle': '%s %s' % (self.model.__verbose_name__, id),
'columns': columns,
'toolbar': self.toolbar,
'item': item,
'model': self.model,
'base_url': self._url,
'relations': relations,
'session': self.session,
'templateDecorator': self.template_decorator,
})
return tpl_add
def __call__(self, request, item_id, *args):
self._initialize(request, *args)
item = self.query.get(item_id)
columns = self._get_model_columns(item)
if request.method == 'POST':
self._save_from_post(request, columns, self.session, item)
if isinstance(item, BaseResponse):
return item
tpl_upd = Template('crud_update', {
'body_class': 'crud_update %s' % self.instance_name,
'title': self.instance_config['name'],
'subtitle': '%s %s' % (
self.model.__verbose_name__,
item
),
'columns': columns,
'toolbar': self.toolbar,
'item_id': item_id,
'item': item,
'model': self.model,
'base_url': self._url,
'relations': None,
'session': self.session,
'templateDecorator': self.template_decorator,
})
return tpl_upd
def render(self,
template,
template_params={},
config=None,
_format='html',
template_lookup_class=TemplateLookup):
controller = self.__class__.__name__.lower()
template_params["controller"] = controller
template_params["this"] = self
template_params["t"] = self.t
template_params["helpers"] = Helper()
template_params["assets"] = self.assets
layout = {
"master": self.master,
"layout": self.layout,
"format": self.format
}
if not template.startswith("/"):
template = controller + "/" + template
return Template(template,
template_params,
config=self.template_config,
_format='html',
template_lookup_class=TemplateLookup,
layout=layout)
def _instance_selection(self, request):
flash(request, 'error', 'Seleccione una instancia.')
return Template('crud_instance_selection', {
'instances': conf('crud.instances.%s' % conf('config.app')),
'body_class': 'instance_selection',
'title': conf('config.name'),
'subtitle': 'Seleccion de instancia'
})
def combo(name, data, column, item=None, **kwargs):
_vars = {
'name': name,
'data': data,
'item': item,
'column': column,
}
_vars.update(kwargs)
return Template('core/bootstrap/combo', _vars).render()
def prepare_response(self, controller, status, content):
if not controller.layouts or not controller.layouts[status]:
return content
layout_template = controller.layouts[status]
print "LAYOUT"
print layout_template
print "TEMPLATE"
print Template(layout_template, {})
def _render(self, request, items):
template_format = request.args.get('format', 'html')
abort(Response(Template('crud_report_list', {
'body_class': 'crud_report_list %s' % self.instance_name,
'title': self.instance_config['name'],
'subtitle': self.name + self.subtitle,
'items': items,
'headers': self.headers,
'columns': self.columns,
'base_url': self._url,
'model': self.model,
'search_term': request.args.get('search', None),
'search_term_end': request.args.get('search2', None),
'search_type': self.search_type,
'download_csv': self.download_csv,
}, _format=template_format), mimetype='text/%s' % template_format))
def __call__(self, request, item_id, *args):
self._initialize(request, *args)
item = self.query.get(item_id)
columns = self._get_model_columns(item)
return Template('crud_show', {
'body_class': 'crud_show %s' % self.instance_name,
'title': self.instance_config['name'],
'subtitle': '%s %s' % (self.model.__verbose_name__, item),
'item': item,
'columns': columns,
'toolbar': self.toolbar,
'id': item_id,
'base_url': self._url,
'read_only': self.read_only,
})
def render(self,
template,
template_params={},
config=None,
_format='html',
template_lookup_class=TemplateLookup):
# controller = self.__class__.__name__.lower()
controller = self.__module__.split('.')[-1]
template_params["controller"] = controller
template_params["this"] = self
template_params["t"] = self.t
template_params["helpers"] = Helper()
template_params["assets"] = self.assets
layout = {
"master": self.master,
"layout": self.layout,
"format": self.format
}
template_params["BASE"] = self.base
template_params["CDN"] = self.cdn
template_params["STATIC"] = self.static
template_params["HOST"] = self.host
template_params["MOUNT"] = self.mount
template_params["get_flash_messages"] = get_flash_messages
if not template.startswith("/"):
template = controller + "/" + template
return Template(template,
template_params,
config=self.template_config,
_format='html',
template_lookup_class=TemplateLookup,
layout=layout).render()
def __call__(self, request, *args):
search_term = request.form.get('search', None)
self._initialize(request, *args)
if search_term is not None and hasattr(self.model, 'search'):
search_term = urlparse.unquote(search_term)
self.query = self.model.search(request, self.session, search_term)
filtered = False
if '__extra_filters__' in self.model.__dict__\
and self.model.__extra_filters__:
for filter in self.model.__extra_filters__:
if hasattr(self.model, filter) and filter in request.args:
f = getattr(self.model, filter)
self.query = f(request, self.query)
filtered = True
break
page = request.args.get('page', 1)
per_page = request.args.get('per_page', str(conf('crud.per_page', 10)))
offset = None
pagination = None
total_items = None
if per_page and per_page != 'all':
offset = (int(page) - 1) * int(per_page)
items = self.query
total_items = items.count()
items = items.limit(per_page).offset(offset).all()
pagination = Pagination(int(page), int(per_page), total_items)
else:
items = self.query.all()
columns = self._get_model_columns(items)
foreign_selection = False
if 'foreign_selection' in request.args:
foreign_selection = True
title = self.instance_config['name']
if self.title:
if callable(self.title):
title = self.title(request, *args)
else:
title = self.title
subtitle = 'Listado de %s' % self.model.__verbose_name_plural__
if self.subtitle:
if callable(self.subtitle):
subtitle = self.subtitle(request, *args)
else:
subtitle = self.subtitle
return Template('crud_list', {
'body_class': 'crud_list %s' % self.instance_name,
'title': title,
'subtitle': subtitle,
'items': items,
'columns': columns,
'pagination': pagination,
'toolbar': self.toolbar,
'id': id,
'current_page': int(page),
'per_page': per_page,
'offset': offset,
'total_items': total_items,
'filtered': filtered,
'foreign_selection': foreign_selection,
'base_url': self._url,
'model': self.model,
'search_term': search_term,
'read_only': self.read_only,
})