class TestProviderTypeSelector:
def setup(self):
self.type_selector = ProviderTypeSelector()
def test_create(self):
pass
@raises(ProviderTypeSelectorError)
def test_no_provider_type(self):
self.type_selector.get_selector('asdf')
def test_dummy_provider_type(self):
self.type_selector.get_selector(DummyEntity)
class TestProviderTypeSelector:
def setup(self):
self.type_selector = ProviderTypeSelector()
def test_create(self):
pass
@raises(ProviderTypeSelectorError)
def test_no_provider_type(self):
self.type_selector.get_selector('asdf')
def test_dummy_provider_type(self):
self.type_selector.get_selector(DummyEntity)
def __init__(self, session, menu_items=None):
if hasattr(self, 'style'):
warnings.warn('style attribute is not supported anymore, '
'resources attribute replaces it', DeprecationWarning,
stacklevel=2)
self.resources = (crud_script,
CSSSource(location='headbottom',
src=self.style))
if menu_items is None:
menu_items = {}
self.menu_items = self._adapt_menu_items(menu_items)
self.helpers = CrudRestControllerHelpers()
self.provider = ProviderTypeSelector().get_selector(self.model).get_provider(self.model, hint=session)
self.session = session
if self.json_dictify is True:
self.json_dictify = {}
#this makes crc declarative
check_types = ['new_form', 'edit_form', 'table', 'table_filler', 'edit_filler']
for type_ in check_types:
if not hasattr(self, type_) and hasattr(self, type_+'_type'):
setattr(self, type_, getattr(self, type_+'_type')(self.session))
# Enable pagination only if table_filler has support for request local __count__
self.pagination_enabled = (self.pagination and isinstance(self.table_filler, RequestLocalTableFiller))
if hasattr(self, 'new_form'):
#register the validators since they are none from the parent class
register_validators(self, 'post', self.new_form)
if hasattr(self, 'edit_form'):
register_validators(self, 'put', self.edit_form)
def __init__(self, session, menu_items=None):
if menu_items is None:
menu_items = {}
self.menu_items = menu_items
self.provider = ProviderTypeSelector().get_selector(self.model).get_provider(self.model, hint=session)
self.session = session
#this makes crc declarative
check_types = ['new_form', 'edit_form', 'table', 'table_filler', 'edit_filler']
for type_ in check_types:
if not hasattr(self, type_) and hasattr(self, type_+'_type'):
setattr(self, type_, getattr(self, type_+'_type')(self.session))
if hasattr(self, 'new_form'):
#register the validators since they are none from the parent class
register_validators(self, 'post', self.new_form)
if hasattr(self, 'edit_form'):
register_validators(self, 'put', self.edit_form)
def __init__(self, session, menu_items=None):
if hasattr(self, 'style'):
warnings.warn(
'style attribute is not supported anymore, '
'resources attribute replaces it',
DeprecationWarning,
stacklevel=2)
self.resources = (crud_script,
CSSSource(location='headbottom', src=self.style))
if menu_items is None:
menu_items = {}
self.menu_items = self._adapt_menu_items(menu_items)
self.helpers = CrudRestControllerHelpers()
self.provider = ProviderTypeSelector().get_selector(
self.model).get_provider(self.model, hint=session)
self.session = session
if self.json_dictify is True:
self.json_dictify = {}
#this makes crc declarative
check_types = [
'new_form', 'edit_form', 'table', 'table_filler', 'edit_filler'
]
for type_ in check_types:
if not hasattr(self, type_) and hasattr(self, type_ + '_type'):
setattr(self, type_,
getattr(self, type_ + '_type')(self.session))
# Enable pagination only if table_filler has support for request local __count__
self.pagination_enabled = (self.pagination and isinstance(
self.table_filler, RequestLocalTableFiller))
if hasattr(self, 'new_form'):
#register the validators since they are none from the parent class
register_validators(self, 'post', self.new_form)
if hasattr(self, 'edit_form'):
register_validators(self, 'put', self.edit_form)
def __init__(self, session, menu_items=None):
if menu_items is None:
menu_items = {}
self.menu_items = menu_items
self.provider = ProviderTypeSelector().get_selector(self.model).get_provider(self.model, hint=session)
self.session = session
#this makes crc declarative
check_types = ['new_form', 'edit_form', 'table', 'table_filler', 'edit_filler']
for type_ in check_types:
if not hasattr(self, type_) and hasattr(self, type_+'_type'):
setattr(self, type_, getattr(self, type_+'_type')(self.session))
if hasattr(self, 'new_form'):
#register the validators since they are none from the parent class
register_validators(self, 'post', self.new_form)
if hasattr(self, 'edit_form'):
register_validators(self, 'put', self.edit_form)
class CrudRestController(RestController):
"""
:variables:
session
database session (drives drop-down menus
menu_items
Dictionary of links to other models in the form model_items[lower_model_name] = Model
title
Title to be used for each page. default: Turbogears Admin System
:modifiers:
model
Model this class is associated with
table
Widget for the table display
table_filler
Class instance with get_value() that defines the JSon stream for the table
edit_form
Form to be used for editing the model
edit_filler
Class instance with a get_value() that defines how we get information for a single
existing record
new_form
Form that defines how we create a form for new data entry.
:Attributes:
menu_items
Dictionary of associated Models (used for menu)
provider
sprox provider for data manipulation
session
link to the database
"""
title = "Turbogears Admin System"
def _before(self, *args, **kw):
tmpl_context.title = self.title
tmpl_context.menu_items = self.menu_items
def __before__(self, *args, **kw):
# this will be removed in 2.1.*
tmpl_context.menu_items = self.menu_items
tmpl_context.title = self.title
def __init__(self, session, menu_items=None):
if menu_items is None:
menu_items = {}
self.menu_items = menu_items
self.provider = ProviderTypeSelector().get_selector(
self.model).get_provider(self.model, hint=session)
self.session = session
#this makes crc declarative
check_types = [
'new_form', 'edit_form', 'table', 'table_filler', 'edit_filler'
]
for type_ in check_types:
if not hasattr(self, type_) and hasattr(self, type_ + '_type'):
setattr(self, type_,
getattr(self, type_ + '_type')(self.session))
if hasattr(self, 'new_form'):
#register the validators since they are none from the parent class
register_validators(self, 'post', self.new_form)
if hasattr(self, 'edit_form'):
register_validators(self, 'put', self.edit_form)
@with_trailing_slash
@expose('tgext.crud.templates.get_all')
@expose('json')
@paginate('value_list', items_per_page=7)
def get_all(self, *args, **kw):
"""Return all records.
Pagination is done by offset/limit in the filler method.
Returns an HTML page with the records if not json.
"""
if pylons.request.response_type == 'application/json':
return self.table_filler.get_value(**kw)
if not getattr(self.table.__class__, '__retrieves_own_value__', False):
values = self.table_filler.get_value(**kw)
else:
values = []
tmpl_context.widget = self.table
return dict(model=self.model.__name__, value_list=values)
@expose('tgext.crud.templates.get_one')
@expose('json')
def get_one(self, *args, **kw):
"""get one record, returns HTML or json"""
#this would probably only be realized as a json stream
tmpl_context.widget = self.edit_form
pks = self.provider.get_primary_fields(self.model)
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
return dict(value=value, model=self.model.__name__)
@expose('tgext.crud.templates.edit')
def edit(self, *args, **kw):
"""Display a page to edit the record."""
tmpl_context.widget = self.edit_form
#pks = self.provider.get_primary_fields(self.model)
log.debug("soyRomperLB= %s" % kw)
###########################################
pks = self.provider.get_primary_fields(self.model)
###########################################
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
value['_method'] = 'PUT'
return dict(value=value, model=self.model.__name__, pk_count=len(pks))
@without_trailing_slash
@expose('sap.templates.desarrollar.lineabase.new')
#@expose('tgext.crud.templates.new')
def new(self, fid=None, *args, **kw):
"""Display a page to show a new record."""
tmpl_context.widget = self.new_form
#return dict(value=kw, model=self.model.__name__)
"""obtiene los id y nombre de los items, de la fase actual """
#items = [x for x in (DBSession.query(Item.id, Item.nombre).filter_by(idFase=fid))]
itemfaseactual = [
x for x in DBSession.query(Item.id, Item.nombre).filter_by(
idFase=fid,
idLineaBase=None,
estado='aprobado',
ultimaversion=1).all()
]
#return dict(value={'idFase':fid}, model=self.model.__name__, item_options=items)
longitud = len(itemfaseactual)
if (longitud == 0):
flash("No existen items aprobados en la fase actual", "error")
redirect('../?fid=' + fid)
else:
return dict(value={'idFase': fid},
model=self.model.__name__,
items_options=itemfaseactual)
@catch_errors(errors, error_handler=new)
@expose()
@registered_validate(error_handler=new)
def post(self, *args, **kw):
ids = kw['items']
longitud = len(ids)
items = DBSession.query(Item).filter_by(idFase=kw['idFase'],
ultimaversion=1).all()
if (longitud > 0):
fase = DBSession.query(Fase).filter_by(id=kw['idFase']).first()
if longitud == len(items):
fase.estado = 'lineaBaseTotal'
else:
fase.estado = 'lineaBaseParcial'
lineabase = self.provider.create(self.model, params=kw)
for indice in range(longitud):
item = DBSession.query(Item).filter_by(id=ids[indice]).first()
item.idLineaBase = lineabase.id
raise redirect('./?fid=' + kw['idFase'])
else:
flash("No ha seleccionado ningun item", "error")
raise redirect('./new/?fid=' + kw['idFase'])
@expose()
@registered_validate(error_handler=edit)
@catch_errors(errors, error_handler=edit)
def put(self, *args, **kw):
"""update"""
pks = self.provider.get_primary_fields(self.model)
for i, pk in enumerate(pks):
if pk not in kw and i < len(args):
kw[pk] = args[i]
log.debug('putLineaBase= %s' % kw)
#lineabase/?fid=21
self.provider.update(self.model, params=kw)
redirect('../' + '../lineabase/?fid=' + str(kw['idFase']))
@expose()
def post_delete(self, *args, **kw):
"""This is the code that actually deletes the record"""
pks = self.provider.get_primary_fields(self.model)
d = {}
for i, arg in enumerate(args):
d[pks[i]] = arg
"""extraer el idFase para poder retornar en el estado anterior """
idfase = DBSession.query(
LineaBase.idFase).filter_by(id=d['id']).first()
self.provider.delete(self.model, d)
redirect('/lineabase/?fid=' + str(idfase[0]))
@expose('tgext.crud.templates.get_delete')
def get_delete(self, *args, **kw):
"""This is the code that creates a confirm_delete page"""
return dict(args=args)
class CrudRestController(RestController):
"""
:variables:
session
database session (drives drop-down menus
menu_items
Dictionary of links to other models in the form model_items[lower_model_name] = Model
title
Title to be used for each page. default: Turbogears Admin System
:modifiers:
model
Model this class is associated with
table
Widget for the table display
table_filler
Class instance with get_value() that defines the JSon stream for the table
edit_form
Form to be used for editing the model
edit_filler
Class instance with a get_value() that defines how we get information for a single
existing record
new_form
Form that defines how we create a form for new data entry.
:Attributes:
menu_items
Dictionary of associated Models (used for menu)
provider
sprox provider for data manipulation
session
link to the database
"""
title = "Turbogears Admin System"
def _before(self, *args, **kw):
tmpl_context.title = self.title
tmpl_context.menu_items = self.menu_items
def __before__(self, *args, **kw):
# this will be removed in 2.1.*
tmpl_context.menu_items = self.menu_items
tmpl_context.title = self.title
def __init__(self, session, menu_items=None):
if menu_items is None:
menu_items = {}
self.menu_items = menu_items
self.provider = ProviderTypeSelector().get_selector(self.model).get_provider(self.model, hint=session)
self.session = session
#this makes crc declarative
check_types = ['new_form', 'edit_form', 'table', 'table_filler', 'edit_filler']
for type_ in check_types:
if not hasattr(self, type_) and hasattr(self, type_+'_type'):
setattr(self, type_, getattr(self, type_+'_type')(self.session))
if hasattr(self, 'new_form'):
#register the validators since they are none from the parent class
register_validators(self, 'post', self.new_form)
if hasattr(self, 'edit_form'):
register_validators(self, 'put', self.edit_form)
@with_trailing_slash
@expose('tgext.crud.templates.get_all')
@expose('json')
@paginate('value_list', items_per_page=7)
def get_all(self, *args, **kw):
"""Return all records.
Pagination is done by offset/limit in the filler method.
Returns an HTML page with the records if not json.
"""
if pylons.request.response_type == 'application/json':
return self.table_filler.get_value(**kw)
if not getattr(self.table.__class__, '__retrieves_own_value__', False):
values = self.table_filler.get_value(**kw)
else:
values = []
tmpl_context.widget = self.table
return dict(model=self.model.__name__, value_list=values)
@expose('tgext.crud.templates.get_one')
@expose('json')
def get_one(self, *args, **kw):
"""get one record, returns HTML or json"""
#this would probably only be realized as a json stream
tmpl_context.widget = self.edit_form
pks = self.provider.get_primary_fields(self.model)
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
return dict(value=value,model=self.model.__name__)
@expose('tgext.crud.templates.edit')
def edit(self,*args, **kw):
"""Aqui esta el codigo de importacion de tipos de items """
log.debug(" kwedit: %s" %kw)
#log.debug(" fidedit: %s" %fid)
pks = self.provider.get_primary_fields(self.model)
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
log.debug(" Soy el ID: %s" % kw[pk])
redirect('../../importartipodeitem/?fid=22')
@without_trailing_slash
@expose("sap.templates.configurar.importartipodeitem.new")
def new(self,fid=None ,*args, **kw):
"""Display a page to show a new record."""
tmpl_context.widget = self.new_form
log.debug('kwwwwnew: %s' %kw)
longitud=len(kw)
if longitud==0:
tiposdeitems=DBSession.query(TipoDeItem.id,TipoDeItem.nombre).filter(TipoDeItem.idFase != fid).all()
return dict(value={"fid": fid}, model=self.model.__name__ ,importar_options=tiposdeitems)
else:
ids= kw['TiposDeItemImportar']
log.debug('ids: %s' %ids)
longitud= len(ids)
for indice in range(longitud):
"""Hace una copia del tipo de item cambiando el idFase """
idTipo= ids[indice]
tipo=DBSession.query(TipoDeItem).filter_by(id=idTipo).first()
log.debug('tiposss: %s' %tipo)
tipocopia=TipoDeItem()
tipocopia.nombre=tipo.nombre
tipocopia.descripcion=tipo.descripcion
log.debug('tipocopia: %s' %tipocopia)
tipocopia.idFase=fid
DBSession.add(tipocopia) #NuevoTipoItem es el nuevo objeto guardado
NuevoTipoItem=DBSession.query(TipoDeItem.id).filter_by(nombre=tipocopia.nombre, descripcion=tipocopia.descripcion, idFase=fid).first()
#Se copia los los atributos especificos del tipo de item
campos=DBSession.query(Campos).filter_by(idTipoDeItem=idTipo).all()
log.debug(campos)
long2=len(campos)
log.debug("long2: %s" %long2)
for x in range(long2):
#se copia los campos pertenecientes al tipo de item pero con "idTipoDeItem" distinto
log.debug("forrrr: %s" %x)
campocopia=Campos()
campocopia.nombre=campos[x].nombre
campocopia.tipoDeDato=campos[x].tipoDeDato
campocopia.idTipoDeItem=NuevoTipoItem.id
DBSession.add(campocopia)
pid=DBSession.query(Fase.idproyec).filter_by(id=fid).first()
redirect("../../fase/?pid="+ str(pid[0]))
"""ids= kw['idFase']
longitud= len(kw['idFase'])
for indice in range(longitud):
kw['idFase']= ids[indice]
msj=DBSession.query(ProyFaseUsuario.idProyecto).filter_by(idProyecto=kw['idProyecto'], iduser=kw['iduser'], idFase=kw['idFase']).first()
if msj == None:
self.provider.create(self.model, params=kw)
else:
flash("El usuario ya fue adherido a la Fase elegida", "error")
redirect('new/?pid='+ kw['idProyecto'])
raise redirect('./?pid='+ kw['idProyecto'])
"""
@catch_errors(errors, error_handler=new)
@expose()
@registered_validate(error_handler=new)
def post(self, *args, **kw):
self.provider.create(self.model, params=kw)
log.debug("posImportar: %s" %kw)
"""ids= kw['idFase']
longitud= len(kw['idFase'])
for indice in range(longitud):
kw['idFase']= ids[indice]
msj=DBSession.query(ProyFaseUsuario.idProyecto).filter_by(idProyecto=kw['idProyecto'], iduser=kw['iduser'], idFase=kw['idFase']).first()
if msj == None:
self.provider.create(self.model, params=kw)
else:
flash("El usuario ya fue adherido a la Fase elegida", "error")
redirect('new/?pid='+ kw['idProyecto'])
raise redirect('./?pid='+ kw['idProyecto'])"""
raise redirect('./')
@expose()
@registered_validate(error_handler=edit)
@catch_errors(errors, error_handler=edit)
def put(self, *args, **kw):
"""update"""
pks = self.provider.get_primary_fields(self.model)
for i, pk in enumerate(pks):
if pk not in kw and i < len(args):
kw[pk] = args[i]
self.provider.update(self.model, params=kw)
redirect('../' * len(pks))
@expose()
def post_delete(self, *args, **kw):
"""This is the code that actually deletes the record"""
pks = self.provider.get_primary_fields(self.model)
d = {}
for i, arg in enumerate(args):
d[pks[i]] = arg
self.provider.delete(self.model, d)
redirect('./' + '../' * (len(pks) - 1))
@expose('tgext.crud.templates.get_delete')
def get_delete(self, *args, **kw):
"""This is the code that creates a confirm_delete page"""
return dict(args=args)
class CrudRestController(RestController):
"""
:variables:
session
database session (drives drop-down menus
menu_items
Dictionary of links to other models in the form model_items[lower_model_name] = Model
title
Title to be used for each page. default: Turbogears Admin System
:modifiers:
model
Model this class is associated with
table
Widget for the table display
table_filler
Class instance with get_value() that defines the JSon stream for the table
edit_form
Form to be used for editing the model
edit_filler
Class instance with a get_value() that defines how we get information for a single
existing record
new_form
Form that defines how we create a form for new data entry.
:Attributes:
menu_items
Dictionary of associated Models (used for menu)
provider
sprox provider for data manipulation
session
link to the database
"""
title = "Turbogears Admin System"
def _before(self, *args, **kw):
tmpl_context.title = self.title
tmpl_context.menu_items = self.menu_items
def __before__(self, *args, **kw):
# this will be removed in 2.1.*
tmpl_context.menu_items = self.menu_items
tmpl_context.title = self.title
def __init__(self, session, menu_items=None):
if menu_items is None:
menu_items = {}
self.menu_items = menu_items
self.provider = ProviderTypeSelector().get_selector(
self.model).get_provider(self.model, hint=session)
self.session = session
#this makes crc declarative
check_types = [
'new_form', 'edit_form', 'table', 'table_filler', 'edit_filler'
]
for type_ in check_types:
if not hasattr(self, type_) and hasattr(self, type_ + '_type'):
setattr(self, type_,
getattr(self, type_ + '_type')(self.session))
if hasattr(self, 'new_form'):
#register the validators since they are none from the parent class
register_validators(self, 'post', self.new_form)
if hasattr(self, 'edit_form'):
register_validators(self, 'put', self.edit_form)
@with_trailing_slash
@expose('tgext.crud.templates.get_all')
@expose('json')
@paginate('value_list', items_per_page=7)
def get_all(self, *args, **kw):
"""Return all records.
Pagination is done by offset/limit in the filler method.
Returns an HTML page with the records if not json.
"""
if pylons.request.response_type == 'application/json':
return self.table_filler.get_value(**kw)
if not getattr(self.table.__class__, '__retrieves_own_value__', False):
values = self.table_filler.get_value(**kw)
else:
values = []
tmpl_context.widget = self.table
return dict(model=self.model.__name__, value_list=values)
@expose('tgext.crud.templates.get_one')
@expose('json')
def get_one(self, *args, **kw):
"""get one record, returns HTML or json"""
#this would probably only be realized as a json stream
tmpl_context.widget = self.edit_form
pks = self.provider.get_primary_fields(self.model)
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
return dict(value=value, model=self.model.__name__)
@expose('tgext.crud.templates.edit')
def edit(self, *args, **kw):
"""Display a page to edit the record."""
tmpl_context.widget = self.edit_form
#pks = self.provider.get_primary_fields(self.model)
###########################################
pks = self.provider.get_primary_fields(self.model)
###########################################
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
value['_method'] = 'PUT'
return dict(value=value, model=self.model.__name__, pk_count=len(pks))
@without_trailing_slash
#@expose('tgext.crud.templates.new')
@expose("sap.templates.desarrollar.itemlineabase.new")
def new(self, lid=None, *args, **kw):
tmpl_context.widget = self.new_form
if len(kw) < 2:
"""-----obtiene el idFase de la en el que esta la linea base------- """
fid = DBSession.query(LineaBase.idFase).filter_by(id=lid).first()
log.debug("fidddd= %s" % fid)
"""-----------------------------------------------------------------"""
emfaseactual = [
x for x in DBSession.query(Item.id, Item.nombre).filter_by(
idFase=fid, idLineaBase=None).all()
]
return dict(value={'lineabase': lid},
model=self.model.__name__,
items_options=itemfaseactual)
"""Este else es como el Post.Como,al guardar no se va al Post,vuelve al new, entonces se le creo este "else" """
else:
kw2 = dict()
kw2['id'] = kw['items']
kw2['idLineaBase'] = kw['lineabase']
self.provider.update(self.model, params=kw2)
raise redirect('../' + '../itemlineabase/?lid=' + kw['lineabase'])
@catch_errors(errors, error_handler=new)
@expose()
@registered_validate(error_handler=new)
def post(self, *args, **kw):
""" este Post, no es llamado en ningun momento, razon por la cual es reemplazado por el "else" que esta en New"""
log.debug("postItemLinea: %s" % kw)
#self.provider.create(self.model, params=kw)
raise redirect('../' + '../itemlineabase/?fid=21')
@expose()
@registered_validate(error_handler=edit)
@catch_errors(errors, error_handler=edit)
def put(self, *args, **kw):
"""update"""
pks = self.provider.get_primary_fields(self.model)
for i, pk in enumerate(pks):
if pk not in kw and i < len(args):
kw[pk] = args[i]
self.provider.update(self.model, params=kw)
redirect('../' * len(pks))
@expose()
def post_delete(self, *args, **kw):
"""This is the code that actually deletes the record"""
pks = self.provider.get_primary_fields(self.model)
d = {}
for i, arg in enumerate(args):
d[pks[i]] = arg
self.provider.delete(self.model, d)
redirect('./' + '../' * (len(pks) - 1))
@expose('tgext.crud.templates.get_delete')
def get_delete(self, *args, **kw):
"""This is the code that creates a confirm_delete page"""
return dict(args=args)
class CrudRestController(RestController):
"""
:initialization options:
**session**
database session
**menu_items**
Dictionary or mapping type of links to other CRUD sections.
This is used to generate the links sidebar of the CRUD interface.
Can be specified in the form ``model_items['lower_model_name'] = ModelClass`` or
``model_items['link'] = 'Name'``.
:class attributes:
**title**
Title to be used for each page. default: ``'Turbogears Admin System'``
**model**
Model this class is associated with.
**remember_values**
List of model attributes that need to keep previous value when not provided
on submission instead of replacing the existing value with an empty one.
It's commonly used with file fields to avoid having to reupload the file
again when the model is edited.
**keep_params**
List of URL parameters that need to be kept around when redirecting between
the various pages of the CRUD controller. Can be used to keep around filters
or sorting when editing a subset of the models.
**search_fields**
Enables searching on some fields, can be ``True``, ``False`` or a list
of fields for which searching should be enabled.
**substring_filters**
Enable substring filtering for some fields, by default is disabled.
Pass ``True`` to enable it on all fields or pass a list of field
names to enable it only on some fields.
**json_dictify**
``True`` or ``False``, enables advanced dictification of retrieved models
when providing JSON responses. This also enables JSON encoding of related entities
for the returned model.
**conditional_update_field**
Name of the field used to perform conditional updates when ``PUT`` method is
used as a REST API. ``None`` disables conditional updates (which is the default).
**pagination**
Dictionary of options for pagination. ``False`` disables pagination.
By default ``{'items_per_page': 7}`` is provided.
Currently the only supported option is ``items_per_page``.
**response_type**
Limit response to a single format, can be: 'application/json' or 'text/html'.
By default tgext.crud will detect expected response from Accept header and
will provide response content according to the expected one. If you want
to avoid HTML access to a plain JSON API you can use this option to limit
valid responses to application/json.
**resources**
A list of CSSSource / JSSource that have to be injected inside CRUD
pages when rendering. By default ``tgext.crud.resources.crud_style`` and
``tgext.crud.resources.crud_script`` are injected.
**table**
The ``sprox.tablebase.TableBase`` Widget instance used to display the table.
By default ``tgext.crud.utils.SortableTableBase`` is used which permits to sort
table by columns.
**table_filler**
The ``sprox.fillerbase.TableFiller`` instance used to retrieve data for the table.
If you want to customize how data is retrieved override the
``TableFiller._do_get_provider_count_and_objs`` method to return different entities and count.
By default ``tgext.crud.utils.RequestLocalTableFiller`` is used which keeps
track of the numer of entities retrieved during the current request to enable pagination.
**edit_form**
Form to be used for editing an existing model.
By default ``sprox.formbase.EditForm`` is used.
**edit_filler**
``sprox.fillerbase.RecordFiller`` subclass used to load the values for
an entity that need to be edited. Override the ``RecordFiller.get_value``
method to provide custom values.
**new_form**
Form that defines how to create a new model.
By default ``sprox.formbase.AddRecordForm`` is used.
"""
title = "Turbogears Admin System"
keep_params = None
remember_values = []
substring_filters = []
search_fields = True # True for automagic
json_dictify = False # True is slower but provides relations
conditional_update_field = None
response_type = None
pagination = {'items_per_page': 7}
resources = ( crud_style,
crud_script )
def _before(self, *args, **kw):
tmpl_context.title = self.title
tmpl_context.menu_items = self.menu_items
tmpl_context.kept_params = self._kept_params()
tmpl_context.crud_helpers = self.helpers
for resource in self.resources:
resource.inject()
force_response_type(self.response_type)
__before__ = _before #This can be removed since 2.2
def _mount_point(self):
try:
mount_point = self.mount_point
except:
mount_point = None
if not mount_point:
#non statically mounted or Old TurboGears, use relative URL
mount_point = '.'
return mount_point
def _kept_params(self):
if not self.keep_params:
return {}
if not request.referer:
from_referer = {}
else:
parsed = url_parse(request.referer)
from_referer = dict(cgi.parse_qsl(parsed.query))
from_referer.update(request.params)
pass_params = {}
for k in self.keep_params:
if k in from_referer:
pass_params[k] = from_referer[k]
return pass_params
def _adapt_menu_items(self, menu_items):
adapted_menu_items = type(menu_items)()
for link, model in menu_items.items():
if inspect.isclass(model):
adapted_menu_items[link + 's'] = model.__name__
else:
adapted_menu_items[link] = model
return adapted_menu_items
def _get_search_fields(self, kw):
if self.search_fields is True:
return [
(field, self.table.__headers__.get(field, field), kw.get(field, False))
for field in self.table.__fields__
if field != '__actions__'
]
elif self.search_fields:
# This allows for customizing the search fields to be shown in the table definition
# search_fields can be either a list of tuples with (field, name) or just a string field = name
search_fields = []
for field in self.search_fields:
if isinstance(field, string_type):
search_fields.append((field, field, kw.get(field, False)))
else:
search_fields.append((field[0], field[1], kw.get(field[0], False)))
return search_fields
else:
# This would be where someone explicitly disabled the search functionality
return []
def _get_current_search(self, search_fields):
if not search_fields:
return None
for field, _, value in search_fields:
if value is not False:
return (field, value)
return (search_fields[0][0], '')
def _dictify(self, value, length=None):
json_dictify = self.json_dictify
if json_dictify is False:
return value
def _dictify(entity):
if hasattr(entity, '__json__'):
return entity.__json__()
else:
return self.provider.dictify(entity, **json_dictify)
if length is not None:
#return a generator, we don't want to consume the whole query if it is paginated
return (_dictify(entity) for entity in value)
else:
return _dictify(value)
def __init__(self, session, menu_items=None):
if hasattr(self, 'style'):
warnings.warn('style attribute is not supported anymore, '
'resources attribute replaces it', DeprecationWarning,
stacklevel=2)
self.resources = (crud_script,
CSSSource(location='headbottom',
src=self.style))
if menu_items is None:
menu_items = {}
self.menu_items = self._adapt_menu_items(menu_items)
self.helpers = CrudRestControllerHelpers()
self.provider = ProviderTypeSelector().get_selector(self.model).get_provider(self.model, hint=session)
self.session = session
if self.json_dictify is True:
self.json_dictify = {}
#this makes crc declarative
check_types = ['new_form', 'edit_form', 'table', 'table_filler', 'edit_filler']
for type_ in check_types:
if not hasattr(self, type_) and hasattr(self, type_+'_type'):
setattr(self, type_, getattr(self, type_+'_type')(self.session))
# Enable pagination only if table_filler has support for request local __count__
self.pagination_enabled = (self.pagination and isinstance(self.table_filler, RequestLocalTableFiller))
if hasattr(self, 'new_form'):
#register the validators since they are none from the parent class
register_validators(self, 'post', self.new_form)
if hasattr(self, 'edit_form'):
register_validators(self, 'put', self.edit_form)
@with_trailing_slash
@expose('genshi:tgext.crud.templates.get_all')
@expose('mako:tgext.crud.templates.get_all')
@expose('jinja:tgext.crud.templates.get_all')
@expose('json:')
@optional_paginate('value_list')
def get_all(self, *args, **kw):
"""Return all records.
Pagination is done by offset/limit in the filler method.
Returns an HTML page with the records if not json.
"""
if self.pagination:
paginator = request.paginators['value_list']
paginator.paginate_items_per_page = self.pagination['items_per_page']
else:
paginator = request.paginators['value_list']
paginator.paginate_items_per_page = -1
paginator.paginate_page = 0
if tg.request.response_type == 'application/json':
adapt_params_for_pagination(kw, self.pagination_enabled)
try:
count, values = self.table_filler._do_get_provider_count_and_objs(**kw)
except Exception as e:
abort(400, detail=unicode_text(e))
values = self._dictify(values, length=count)
if self.pagination_enabled:
values = SmartPaginationCollection(values, count)
return dict(value_list=values)
if not getattr(self.table.__class__, '__retrieves_own_value__', False):
kw.pop('substring_filters', None)
if self.substring_filters is True:
substring_filters = list(set(kw.keys()) - set(['limit', 'offset', 'order_by', 'desc']))
else:
substring_filters = self.substring_filters
adapt_params_for_pagination(kw, self.pagination_enabled)
try:
values = self.table_filler.get_value(substring_filters=substring_filters, **kw)
except Exception as e:
flash('Invalid search query "%s": %s' % (request.query_string, e), 'warn')
# Reset all variables to sane defaults
kw = {}
values = []
self.table_filler.__count__ = 0
if self.pagination_enabled:
values = SmartPaginationCollection(values, self.table_filler.__count__)
else:
values = []
tmpl_context.widget = self.table
search_fields = self._get_search_fields(kw)
current_search = self._get_current_search(search_fields)
return dict(model=self.model.__name__, value_list=values,
mount_point=self._mount_point(),
headers=search_fields, # Just for backwards compatibility
search_fields=search_fields, current_search=current_search)
@expose('genshi:tgext.crud.templates.get_one')
@expose('mako:tgext.crud.templates.get_one')
@expose('jinja:tgext.crud.templates.get_one')
@expose('json:')
def get_one(self, *args, **kw):
"""get one record, returns HTML or json"""
#this would probably only be realized as a json stream
kw = map_args_to_pks(args, {})
if tg.request.response_type == 'application/json':
obj = self.provider.get_obj(self.model, kw)
if obj is None:
tg.response.status_code = 404
elif self.conditional_update_field is not None:
tg.response.last_modified = getattr(obj, self.conditional_update_field)
return dict(model=self.model.__name__,
value=self._dictify(obj))
tmpl_context.widget = self.edit_form
value = self.edit_filler.get_value(kw)
return dict(value=value, model=self.model.__name__)
@expose('genshi:tgext.crud.templates.edit')
@expose('mako:tgext.crud.templates.edit')
@expose('jinja:tgext.crud.templates.edit')
def edit(self, *args, **kw):
"""Display a page to edit the record."""
pks = self.provider.get_primary_fields(self.model)
kw = map_args_to_pks(args, {})
tmpl_context.widget = self.edit_form
value = self.edit_filler.get_value(kw)
value['_method'] = 'PUT'
return dict(value=value, model=self.model.__name__, pk_count=len(pks))
@without_trailing_slash
@expose('genshi:tgext.crud.templates.new')
@expose('mako:tgext.crud.templates.new')
@expose('jinja:tgext.crud.templates.new')
def new(self, *args, **kw):
"""Display a page to show a new record."""
tmpl_context.widget = self.new_form
return dict(value=kw, model=self.model.__name__)
@expose(content_type='text/html')
@expose('json:', content_type='application/json')
@before_validate(allow_json_parameters)
@catch_errors(errors, error_handler=new)
@registered_validate(error_handler=new)
def post(self, *args, **kw):
obj = self.provider.create(self.model, params=kw)
if tg.request.response_type == 'application/json':
if obj is not None and self.conditional_update_field is not None:
tg.response.last_modified = getattr(obj, self.conditional_update_field)
return dict(model=self.model.__name__,
value=self._dictify(obj))
return redirect('./', params=self._kept_params())
@expose(content_type='text/html')
@expose('json:', content_type='application/json')
@before_validate(allow_json_parameters)
@before_validate(map_args_to_pks)
@registered_validate(error_handler=edit)
@catch_errors(errors, error_handler=edit)
def put(self, *args, **kw):
"""update"""
omit_fields = []
if getattr(self, 'edit_form', None):
omit_fields.extend(self.edit_form.__omit_fields__)
for remembered_value in self.remember_values:
value = kw.get(remembered_value)
if value is None or value == '':
omit_fields.append(remembered_value)
obj = self.provider.get_obj(self.model, kw)
#This should actually by done by provider.update to make it atomic
can_modify = True
if obj is not None and self.conditional_update_field is not None and \
tg.request.if_unmodified_since is not None and \
tg.request.if_unmodified_since < getattr(obj, self.conditional_update_field):
can_modify = False
if obj is not None and can_modify:
obj = self.provider.update(self.model, params=kw, omit_fields=omit_fields)
if tg.request.response_type == 'application/json':
if obj is None:
tg.response.status_code = 404
elif can_modify is False:
tg.response.status_code = 412
elif self.conditional_update_field is not None:
tg.response.last_modified = getattr(obj, self.conditional_update_field)
return dict(model=self.model.__name__,
value=self._dictify(obj))
pks = self.provider.get_primary_fields(self.model)
return redirect('../' * len(pks), params=self._kept_params())
@expose(content_type='text/html')
@expose('json:', content_type='application/json')
def post_delete(self, *args, **kw):
"""This is the code that actually deletes the record"""
kw = map_args_to_pks(args, {})
obj = None
if kw:
obj = self.provider.get_obj(self.model, kw)
if obj is not None:
self.provider.delete(self.model, kw)
if tg.request.response_type == 'application/json':
return dict()
pks = self.provider.get_primary_fields(self.model)
return redirect('./' + '../' * (len(pks) - 1), params=self._kept_params())
@expose('genshi:tgext.crud.templates.get_delete')
@expose('jinja:tgext.crud.templates.get_delete')
def get_delete(self, *args, **kw):
"""This is the code that creates a confirm_delete page"""
return dict(args=args)
class CrudRestController(RestController):
"""
:variables:
session
database session (drives drop-down menus
menu_items
Dictionary of links to other models in the form model_items[lower_model_name] = Model
title
Title to be used for each page. default: Turbogears Admin System
:modifiers:
model
Model this class is associated with
table
Widget for the table display
table_filler
Class instance with get_value() that defines the JSon stream for the table
edit_form
Form to be used for editing the model
edit_filler
Class instance with a get_value() that defines how we get information for a single
existing record
new_form
Form that defines how we create a form for new data entry.
:Attributes:
menu_items
Dictionary of associated Models (used for menu)
provider
sprox provider for data manipulation
session
link to the database
"""
title = "Turbogears Admin System"
def _before(self, *args, **kw):
tmpl_context.title = self.title
tmpl_context.menu_items = self.menu_items
def __before__(self, *args, **kw):
# this will be removed in 2.1.*
tmpl_context.menu_items = self.menu_items
tmpl_context.title = self.title
def __init__(self, session, menu_items=None):
if menu_items is None:
menu_items = {}
self.menu_items = menu_items
self.provider = ProviderTypeSelector().get_selector(
self.model).get_provider(self.model, hint=session)
self.session = session
#this makes crc declarative
check_types = [
'new_form', 'edit_form', 'table', 'table_filler', 'edit_filler'
]
for type_ in check_types:
if not hasattr(self, type_) and hasattr(self, type_ + '_type'):
setattr(self, type_,
getattr(self, type_ + '_type')(self.session))
if hasattr(self, 'new_form'):
#register the validators since they are none from the parent class
register_validators(self, 'post', self.new_form)
if hasattr(self, 'edit_form'):
register_validators(self, 'put', self.edit_form)
@with_trailing_slash
@expose('sap.templates.desarrollar.relacionitem.get_all')
@expose('json')
@paginate('value_list', items_per_page=7)
def get_all(self, *args, **kw):
"""Return all records.
Pagination is done by offset/limit in the filler method.
Returns an HTML page with the records if not json.
"""
if pylons.request.response_type == 'application/json':
return self.table_filler.get_value(**kw)
if not getattr(self.table.__class__, '__retrieves_own_value__', False):
values = self.table_filler.get_value(**kw)
else:
values = []
longitud = len(values)
for fila in range(longitud):
values[fila]['idItem1'] = DBSession.query(
Item.nombre).filter_by(id=values[fila]['idItem1']).one()
values[fila]['idItem2'] = DBSession.query(
Item.nombre).filter_by(id=values[fila]['idItem2']).one()
tmpl_context.widget = self.table
return dict(model=self.model.__name__, value_list=values)
@expose('tgext.crud.templates.get_one')
@expose('json')
def get_one(self, *args, **kw):
"""get one record, returns HTML or json"""
#this would probably only be realized as a json stream
tmpl_context.widget = self.edit_form
pks = self.provider.get_primary_fields(self.model)
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
return dict(value=value, model=self.model.__name__)
@expose('tgext.crud.templates.edit')
def edit(self, *args, **kw):
"""Display a page to edit the record."""
tmpl_context.widget = self.edit_form
#pks = self.provider.get_primary_fields(self.model)
###########################################
pks = self.provider.get_primary_fields(self.model)
###########################################
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
value['_method'] = 'PUT'
return dict(value=value, model=self.model.__name__, pk_count=len(pks))
@without_trailing_slash
@expose('sap.templates.desarrollar.relacionitem.new')
def new(self, iid=None, *args, **kw):
"""Display a page to show a new record."""
tmpl_context.widget = self.new_form
"""Fase a la cual pertenece el item que se quiere relacionar"""
faseActual = DBSession.query(Item.idFase).filter_by(id=iid).one()
"""Proyecto al cual pertenece la fase que hallamos en la linea anterior"""
proyecto = DBSession.query(
Fase.idproyec).filter_by(id=faseActual).one()
listalineabase = DBSession.query(LineaBase).filter_by(
idFase=faseActual).all()
desarrollo = True
longitud = len(listalineabase)
for x in range(longitud):
if str(listalineabase[x].estado).__eq__('cerrada'):
desarrollo = False
if desarrollo & longitud > 0:
fase = DBSession.query(Fase).filter_by(id=Item.idFase).first()
fase.estado = 'desarrollo'
allFaseSgte = DBSession.query(Fase).filter(
(Fase.idproyec == proyecto) & (Fase.id > faseActual)).all()
longFaseSgte = len(allFaseSgte)
if (longFaseSgte > 0):
allFaseSgte[0].estado = 'desarrollo'
lineabasesgte = DBSession.query(LineaBase).filter_by(
idFase=allFaseSgte[0].id).all()
for x in range(len(lineabasesgte)):
if str(lineabasesgte[x].estado).__eq__('cerrada'):
lineabasesgte[x].estado = 'comprometida'
itemlbsgte = DBSession.query(Item).filter_by(
idLineaBase=lineabasesgte[x].id,
ultimaversion=1).all()
for y in range(len(itemlbsgte)):
itemlbsgte[y].estado = 'revision'
"""Proyecto al cual pertenece la fase que hallamos en la linea anterior"""
proyecto = DBSession.query(
Fase.idproyec).filter_by(id=faseActual).one()
"""Todas las fases que pertenecen al proyecto en cuestion"""
allFase = DBSession.query(Fase).filter((Fase.idproyec == proyecto)
& (Fase.id < faseActual)).all()
longFase = len(allFase)
"""Todos los item de la fase actual"""
listaActual = DBSession.query(Item.id, Item.nombre).\
filter_by(idFase=faseActual, ultimaversion=1).all()
"""Todas las relaciones existentes"""
relaciones = DBSession.query(RelacionItem.idItem1,
RelacionItem.idItem2).all()
longRel = len(relaciones)
#La fase inmediatamente inferior es la fase anterior
listaAnterior = []
#Se comprueba que exista una fase anterior
if (longFase > 0):
listaAnterior = DBSession.query(Item.id, Item.nombre).\
filter((Item.idFase==allFase[longFase-1].id) & (Item.ultimaversion==1)\
& (Item.idLineaBase != None) & (Item.estado.__eq__('aprobado'))).all()
log.debug(listaAnterior)
#Eliminar los item ya relacionados de la lista de fase anterior
for x in range(longRel):
#relaciones[x][0] = idItem1
#relaciones[x][1] = idItem2
longitud = len(listaAnterior)
if iid.__eq__("%s" % relaciones[x][0]):
for y in range(longitud):
if listaAnterior[y][0] == relaciones[x][1]:
listaAnterior.remove(listaAnterior[y])
break
elif iid.__eq__("%s" % relaciones[x][1]):
for y in range(longitud):
if listaAnterior[y][0] == relaciones[x][0]:
listaAnterior.remove(listaAnterior[y])
break
"""-----------------------------------------------"""
"""-------------------FASE ACTUAL-------------------"""
#Eliminar el item que se quiere relacionar de la lista de fase actual
longitud = len(listaActual)
for x in range(longitud):
if iid.__eq__("%s" % listaActual[x][0]):
listaActual.remove(listaActual[x])
break
#Eliminar los item ya relacionados de la lista de fase actual
for x in range(longRel):
#relaciones[x][0] = idItem1
#relaciones[x][1] = idItem2
longitud = len(listaActual)
if iid.__eq__("%s" % relaciones[x][0]):
for y in range(longitud):
if listaActual[y][0] == relaciones[x][1]:
listaActual.remove(listaActual[y])
break
self.controlCiclo(relaciones, listaActual, iid)
"""------------------------------------------------"""
#return dict(value=kw, model=self.model.__name__)
return dict(value={'idItem1': iid},
model=self.model.__name__,
actual_options=listaActual,
anterior_options=listaAnterior)
def controlCiclo(self, *args):
relaciones = args[0]
listaActual = args[1]
iid = args[2]
longRel = len(relaciones)
for x in range(longRel):
#relaciones[x][0] = idItem1
#relaciones[x][1] = idItem2
if int(iid) == int(relaciones[x][1]):
longitud = len(listaActual)
for y in range(longitud):
if listaActual[y][0] == relaciones[x][0]:
aux = listaActual[y]
self.controlCiclo(relaciones, listaActual,
relaciones[x][0])
listaActual.remove(aux)
break
@catch_errors(errors, error_handler=new)
@expose()
@registered_validate(error_handler=new)
def post(self, *args, **kw):
"""Se crea un nuevo item"""
itemeditado = DBSession.query(Item).filter_by(id=kw['idItem1']).first()
itemnuevo = Item()
itemnuevo.version = itemeditado.version + 1
itemnuevo.idTipoDeItem = itemeditado.idTipoDeItem
itemnuevo.idFase = itemeditado.idFase
itemnuevo.idLineaBase = itemeditado.idLineaBase
itemnuevo.fechaCreacion = itemeditado.fechaCreacion
itemnuevo.nrohistorial = itemeditado.nrohistorial
itemnuevo.ultimaversion = 1
itemeditado.ultimaversion = 0
itemnuevo.estado = 'modificado'
itemnuevo.complejidad = itemeditado.complejidad
itemnuevo.nombre = itemeditado.nombre
DBSession.add(itemnuevo)
DBSession.flush()
"""-------------------------"""
""" Crea las nuevas relaciones"""
kw['idItem1'] = itemnuevo.id
""" Se crea las relaciones"""
ids = kw['idItem2']
longitud = len(kw['idItem2'])
for indice in range(longitud):
kw['idItem2'] = ids[indice]
self.provider.create(self.model, params=kw)
ids = kw['idItem2Anterior']
longitud = len(kw['idItem2Anterior'])
for indice in range(longitud):
kw['idItem2'] = ids[indice]
self.provider.create(self.model, params=kw)
"""Realiza copia de los valores de los atributos especificos"""
atributoeditado = DBSession.query(DetalleItem).filter_by(
iditem=itemeditado.id).all()
for objeto in atributoeditado:
nuevoDetalle = DetalleItem()
nuevoDetalle.tipo = objeto.tipo
nuevoDetalle.nombrecampo = objeto.nombrecampo
nuevoDetalle.valor = objeto.valor
nuevoDetalle.iditem = itemnuevo.id
DBSession.add(nuevoDetalle)
"""Realiza copia de los adjuntos"""
adjuntositemeditado = DBSession.query(Adjuntos).filter_by(
idItem=itemeditado.id).all()
for adj in adjuntositemeditado:
itemnuevoadjunto = Adjuntos()
itemnuevoadjunto.idItem = itemnuevo.id
itemnuevoadjunto.filename = adj.filename
itemnuevoadjunto.filecontent = adj.filecontent
DBSession.add(itemnuevoadjunto)
"""Copia las relaciones """
#itemnuevo=DBSession.query(Item.id).filter_by(nrohistorial=nuevo['nrohistorial'], ultimaversion=1).first()
relaciones = DBSession.query(
RelacionItem.idItem1, RelacionItem.idItem2).filter(
(RelacionItem.idItem2 == itemeditado.id)
| (RelacionItem.idItem1 == itemeditado.id)).all()
longitud = len(relaciones)
for x in range(longitud):
newRelation = {}
if int(itemeditado.id) == int(relaciones[x][0]):
newRelation['idItem1'] = int(itemnuevo.id)
newRelation['idItem2'] = relaciones[x][1]
self.provider.create(RelacionItem, params=newRelation)
elif int(itemeditado.id) == int(relaciones[x][1]):
newRelation['idItem1'] = relaciones[x][0]
newRelation['idItem2'] = int(itemnuevo.id)
self.provider.create(RelacionItem, params=newRelation)
raise redirect('./?iid=' + str(kw['idItem1']))
@expose()
@registered_validate(error_handler=edit)
@catch_errors(errors, error_handler=edit)
def put(self, *args, **kw):
"""update"""
pks = self.provider.get_primary_fields(self.model)
for i, pk in enumerate(pks):
if pk not in kw and i < len(args):
kw[pk] = args[i]
self.provider.update(self.model, params=kw)
redirect('../' * len(pks))
@expose()
def post_delete(self, *args, **kw):
"""This is the code that actually deletes the record"""
pks = self.provider.get_primary_fields(self.model)
d = {}
for i, arg in enumerate(args):
d[pks[i]] = arg
self.provider.delete(self.model, d)
redirect('./' + '../' * (len(pks) - 1))
@expose('tgext.crud.templates.get_delete')
def get_delete(self, *args, **kw):
"""This is the code that creates a confirm_delete page"""
return dict(args=args)
class CrudRestController(RestController):
"""
:variables:
session
database session (drives drop-down menus
menu_items
Dictionary of links to other models in the form model_items[lower_model_name] = Model
title
Title to be used for each page. default: Turbogears Admin System
:modifiers:
model
Model this class is associated with
table
Widget for the table display
table_filler
Class instance with get_value() that defines the JSon stream for the table
edit_form
Form to be used for editing the model
edit_filler
Class instance with a get_value() that defines how we get information for a single
existing record
new_form
Form that defines how we create a form for new data entry.
:Attributes:
menu_items
Dictionary of associated Models (used for menu)
provider
sprox provider for data manipulation
session
link to the database
"""
title = "Turbogears Admin System"
def _before(self, *args, **kw):
tmpl_context.title = self.title
tmpl_context.menu_items = self.menu_items
def __before__(self, *args, **kw):
# this will be removed in 2.1.*
tmpl_context.menu_items = self.menu_items
tmpl_context.title = self.title
def __init__(self, session, menu_items=None):
if menu_items is None:
menu_items = {}
self.menu_items = menu_items
self.provider = ProviderTypeSelector().get_selector(
self.model).get_provider(self.model, hint=session)
self.session = session
#this makes crc declarative
check_types = [
'new_form', 'edit_form', 'table', 'table_filler', 'edit_filler'
]
for type_ in check_types:
if not hasattr(self, type_) and hasattr(self, type_ + '_type'):
setattr(self, type_,
getattr(self, type_ + '_type')(self.session))
if hasattr(self, 'new_form'):
#register the validators since they are none from the parent class
register_validators(self, 'post', self.new_form)
if hasattr(self, 'edit_form'):
register_validators(self, 'put', self.edit_form)
@with_trailing_slash
@expose('tgext.crud.templates.get_all')
@expose('json')
@paginate('value_list', items_per_page=7)
def get_all(self, *args, **kw):
"""Return all records.
Pagination is done by offset/limit in the filler method.
Returns an HTML page with the records if not json.
"""
if pylons.request.response_type == 'application/json':
return self.table_filler.get_value(**kw)
if not getattr(self.table.__class__, '__retrieves_own_value__', False):
values = self.table_filler.get_value(**kw)
else:
values = []
longitud = len(values)
for fila in range(longitud):
complejidad = int(values[fila]['complejidad'])
values[fila]['idFase'] = DBSession.query(
Fase.nombre).filter_by(id=values[fila]['idFase']).first()
lineabase = values[fila]['idLineaBase']
if lineabase != 'None':
values[fila]['idLineaBase'] = DBSession.query(LineaBase.nombre)\
.filter_by(id=lineabase).first()
else:
values[fila]['idLineaBase'] = 'Sin linea base'
if (complejidad == 1):
values[fila]['complejidad'] = 'Muy baja (1)'
elif (complejidad == 2):
values[fila]['complejidad'] = 'Baja (2)'
elif (complejidad == 3):
values[fila]['complejidad'] = 'Media (3)'
elif (complejidad == 4):
values[fila]['complejidad'] = 'Alta (4)'
else:
values[fila]['complejidad'] = 'Muy alta (5)'
tmpl_context.widget = self.table
return dict(model=self.model.__name__, value_list=values)
@expose('tgext.crud.templates.get_one')
@expose('json')
def get_one(self, *args, **kw):
"""get one record, returns HTML or json"""
#this would probably only be realized as a json stream
tmpl_context.widget = self.edit_form
pks = self.provider.get_primary_fields(self.model)
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
return dict(value=value, model=self.model.__name__)
@expose('tgext.crud.templates.edit')
def edit(self, *args, **kw):
"""este codigo es ejecutado cuando se revierte un item """
pks = self.provider.get_primary_fields(self.model)
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
"""-----------Se obtiene el item a revertir -------------"""
item = DBSession.query(Item).filter_by(id=kw['id']).first()
"""------------------------------------------------------"""
"""------obtine el numero de la mayor version del item---"""
versionmayor = DBSession.query(Item.version).filter_by(
nrohistorial=item.nrohistorial, ultimaversion=1).first()
"""------------------------------------------------------"""
""" ---el item con la version mayor, cambia su ultimaversion a cero --- """
item3 = DBSession.query(Item).filter_by(nrohistorial=item.nrohistorial,
ultimaversion=1).first()
log.debug('item3= %s' % item3)
item3.ultimaversion = 0
log.debug("versionmayor= %s" % versionmayor[0])
item2 = Item()
item2.nombre = item.nombre
item2.idTipoDeItem = item.idTipoDeItem
item2.idFase = item.idFase
item2.idLineaBase = item.idLineaBase
"""el item a revertir aumenta su version a la ultima y el
el item con la ultima version, "ultima version" pasa a 0 """
item2.version = versionmayor[0] + 1
item2.ultimaversion = 1
item2.estado = item.estado
item2.complejidad = item.complejidad
item2.fechaCreacion = item.fechaCreacion
item2.nrohistorial = item.nrohistorial
DBSession.add(item2)
"""Realiza copia de los valores de los atributos especificos"""
atributoeditado = DBSession.query(DetalleItem).filter_by(
iditem=item.id).all()
for objeto in atributoeditado:
nuevoDetalle = DetalleItem()
nuevoDetalle.tipo = objeto.tipo
nuevoDetalle.nombrecampo = objeto.nombrecampo
nuevoDetalle.valor = objeto.valor
nuevoDetalle.iditem = item2.id #el ID del nuevo item
DBSession.add(nuevoDetalle)
"""Realiza copia de los adjuntos"""
adjuntositemeditado = DBSession.query(Adjuntos).filter_by(
idItem=item.id).all()
for adj in adjuntositemeditado:
log.debug("adj: %s" % adj)
itemnuevoadjunto = Adjuntos()
itemnuevoadjunto.idItem = item2.id
itemnuevoadjunto.filename = adj.filename
itemnuevoadjunto.filecontent = adj.filecontent
DBSession.add(itemnuevoadjunto)
"""Copia las relaciones """
relaciones = DBSession.query(
RelacionItem.idItem1,
RelacionItem.idItem2).filter((RelacionItem.idItem2 == item.id) | (
RelacionItem.idItem1 == item.id)).all()
longitud = len(relaciones)
for x in range(longitud):
newRelation = RelacionItem()
if int(item.id) == int(relaciones[x][0]):
newRelation.idItem1 = int(item2.id)
newRelation.idItem2 = relaciones[x][1]
DBSession.add(newRelation)
#self.provider.create(RelacionItem, params=newRelation)
elif int(item.id) == int(relaciones[x][1]):
newRelation.idItem1 = relaciones[x][0]
newRelation.idItem2 = int(item2.id)
DBSession.add(newRelation)
redirect('../' + '../item/?fid=' + str(item.idFase))
@without_trailing_slash
@expose('tgext.crud.templates.new')
def new(self, *args, **kw):
"""Display a page to show a new record."""
tmpl_context.widget = self.new_form
return dict(value=kw, model=self.model.__name__)
@catch_errors(errors, error_handler=new)
@expose()
@registered_validate(error_handler=new)
def post(self, *args, **kw):
self.provider.create(self.model, params=kw)
#########
#if len(kw['idproyec']) > 0:
# raise redirect('./?pid='+kw['idproyec'])
#else:
# if len(kw['idFase']) > 0:
# raise redirect('./?fid='+kw['idFase'])
# else:
# raise redirect('./')
#########
raise redirect('./')
@expose()
@registered_validate(error_handler=edit)
@catch_errors(errors, error_handler=edit)
def put(self, *args, **kw):
"""update"""
pks = self.provider.get_primary_fields(self.model)
for i, pk in enumerate(pks):
if pk not in kw and i < len(args):
kw[pk] = args[i]
self.provider.update(self.model, params=kw)
redirect('../' * len(pks))
@expose()
def post_delete(self, *args, **kw):
"""This is the code that actually deletes the record"""
pks = self.provider.get_primary_fields(self.model)
d = {}
for i, arg in enumerate(args):
d[pks[i]] = arg
self.provider.delete(self.model, d)
redirect('./' + '../' * (len(pks) - 1))
@expose('tgext.crud.templates.get_delete')
def get_delete(self, *args, **kw):
"""This is the code that creates a confirm_delete page"""
return dict(args=args)
class CrudRestController(RestController):
"""
:variables:
session
database session (drives drop-down menus
menu_items
Dictionary of links to other models in the form model_items[lower_model_name] = Model
title
Title to be used for each page. default: Turbogears Admin System
:modifiers:
model
Model this class is associated with
table
Widget for the table display
table_filler
Class instance with get_value() that defines the JSon stream for the table
edit_form
Form to be used for editing the model
edit_filler
Class instance with a get_value() that defines how we get information for a single
existing record
new_form
Form that defines how we create a form for new data entry.
:Attributes:
menu_items
Dictionary of associated Models (used for menu)
provider
sprox provider for data manipulation
session
link to the database
"""
title = "Turbogears Admin System"
def _before(self, *args, **kw):
tmpl_context.title = self.title
tmpl_context.menu_items = self.menu_items
def __before__(self, *args, **kw):
# this will be removed in 2.1.*
tmpl_context.menu_items = self.menu_items
tmpl_context.title = self.title
def __init__(self, session, menu_items=None):
if menu_items is None:
menu_items = {}
self.menu_items = menu_items
self.provider = ProviderTypeSelector().get_selector(self.model).get_provider(self.model, hint=session)
self.session = session
#this makes crc declarative
check_types = ['new_form', 'edit_form', 'table', 'table_filler', 'edit_filler']
for type_ in check_types:
if not hasattr(self, type_) and hasattr(self, type_+'_type'):
setattr(self, type_, getattr(self, type_+'_type')(self.session))
if hasattr(self, 'new_form'):
#register the validators since they are none from the parent class
register_validators(self, 'post', self.new_form)
if hasattr(self, 'edit_form'):
register_validators(self, 'put', self.edit_form)
@with_trailing_slash
@expose('tgext.crud.templates.get_all')
@expose('json')
@paginate('value_list', items_per_page=7)
def get_all(self, *args, **kw):
"""Return all records.
Pagination is done by offset/limit in the filler method.
Returns an HTML page with the records if not json.
"""
if pylons.request.response_type == 'application/json':
return self.table_filler.get_value(**kw)
if not getattr(self.table.__class__, '__retrieves_own_value__', False):
values = self.table_filler.get_value(**kw)
else:
values = []
for value in values:
value['idFase'] = DBSession.query(Fase.nombre).filter_by(id=value['idFase']).first()
tmpl_context.widget = self.table
return dict(model=self.model.__name__, value_list=values)
@expose('tgext.crud.templates.get_one')
@expose('json')
def get_one(self, *args, **kw):
"""get one record, returns HTML or json"""
#this would probably only be realized as a json stream
tmpl_context.widget = self.edit_form
pks = self.provider.get_primary_fields(self.model)
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
return dict(value=value,model=self.model.__name__)
@expose('sap.templates.configurar.tipodeitem.edit')
def edit(self, *args, **kw):
"""Display a page to edit the record."""
tmpl_context.widget = self.edit_form
#pks = self.provider.get_primary_fields(self.model)
###########################################
pks = self.provider.get_primary_fields(self.model)
###########################################
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
value['_method'] = 'PUT'
return dict(value=value, model=self.model.__name__, pk_count=len(pks))
@without_trailing_slash
@expose('sap.templates.configurar.tipodeitem.new')
def new(self,fid=None,*args, **kw):
"""Display a page to show a new record."""
tmpl_context.widget = self.new_form
#return dict(value=kw, model=self.model.__name__)
return dict(value={'idFase':fid}, model=self.model.__name__)
@catch_errors(errors, error_handler=new)
@expose()
@registered_validate(error_handler=new)
def post(self, *args, **kw):
if kw['nombre']==None:
flash("El tipo de item debe tener un nombre" , "error")
redirect('/tipodeitem/new/?fid='+ str(kw['idFase']))
nombreduplicado=DBSession.query(TipoDeItem.nombre).filter((TipoDeItem.idFase==kw['idFase']) &(TipoDeItem.nombre==kw['nombre'])).first()
if nombreduplicado != None :
flash("Ya existe \"Tipo de Item\" con el mismo nombre" , "error")
redirect('/tipodeitem/new/?fid='+ str(kw['idFase']))
idtipo=self.provider.create(self.model, params=kw)
raise redirect("/campos/?tid="+str(idtipo.id))
@expose()
@registered_validate(error_handler=edit)
@catch_errors(errors, error_handler=edit)
def put(self, *args, **kw):
"""update"""
pks = self.provider.get_primary_fields(self.model)
for i, pk in enumerate(pks):
if pk not in kw and i < len(args):
kw[pk] = args[i]
self.provider.update(self.model, params=kw)
fasedeltipo= DBSession.query(TipoDeItem.idFase).filter_by(id=kw[pk]).first()
log.debug('fasedeltipo: %s' %fasedeltipo)
redirect('../?fid='+str(fasedeltipo[0]))
@expose()
def post_delete(self, *args, **kw):
"""This is the code that actually deletes the record"""
pks = self.provider.get_primary_fields(self.model)
d = {}
for i, arg in enumerate(args):
d[pks[i]] = arg
#log.debug("ValorD: %s" %d['id'])
idfase= DBSession.query(TipoDeItem.idFase).filter_by(id=d['id']).first()
self.provider.delete(self.model, d)
log.debug("ValorIdFase: %s" %idfase[0])
redirect('/tipodeitem/?fid='+ str(idfase[0]))
#raise redirect("/campos/?tid="+str(idtipo[0]))
#redirect('../' + '../?fid=' + d['idFase'])
#redirect('../' + '../?pid='+ d['idProyecto'])
@expose('tgext.crud.templates.get_delete')
def get_delete(self, *args, **kw):
"""This is the code that creates a confirm_delete page"""
return dict(args=args)
def setup(self):
self.type_selector = ProviderTypeSelector()
class CrudRestController(RestController):
"""
:variables:
session
database session (drives drop-down menus
menu_items
Dictionary of links to other models in the form model_items[lower_model_name] = Model
title
Title to be used for each page. default: Turbogears Admin System
:modifiers:
model
Model this class is associated with
table
Widget for the table display
table_filler
Class instance with get_value() that defines the JSon stream for the table
edit_form
Form to be used for editing the model
edit_filler
Class instance with a get_value() that defines how we get information for a single
existing record
new_form
Form that defines how we create a form for new data entry.
:Attributes:
menu_items
Dictionary of associated Models (used for menu)
provider
sprox provider for data manipulation
session
link to the database
"""
title = "Turbogears Admin System"
def _before(self, *args, **kw):
tmpl_context.title = self.title
tmpl_context.menu_items = self.menu_items
def __before__(self, *args, **kw):
# this will be removed in 2.1.*
tmpl_context.menu_items = self.menu_items
tmpl_context.title = self.title
def __init__(self, session, menu_items=None):
if menu_items is None:
menu_items = {}
self.menu_items = menu_items
self.provider = ProviderTypeSelector().get_selector(self.model).get_provider(self.model, hint=session)
self.session = session
#this makes crc declarative
check_types = ['new_form', 'edit_form', 'table', 'table_filler', 'edit_filler']
for type_ in check_types:
if not hasattr(self, type_) and hasattr(self, type_+'_type'):
setattr(self, type_, getattr(self, type_+'_type')(self.session))
if hasattr(self, 'new_form'):
#register the validators since they are none from the parent class
register_validators(self, 'post', self.new_form)
if hasattr(self, 'edit_form'):
register_validators(self, 'put', self.edit_form)
@with_trailing_slash
@expose('sap.templates.desarrollar.relacionitem.get_all')
@expose('json')
@paginate('value_list', items_per_page=7)
def get_all(self, *args, **kw):
"""Return all records.
Pagination is done by offset/limit in the filler method.
Returns an HTML page with the records if not json.
"""
if pylons.request.response_type == 'application/json':
return self.table_filler.get_value(**kw)
if not getattr(self.table.__class__, '__retrieves_own_value__', False):
values = self.table_filler.get_value(**kw)
else:
values = []
longitud=len(values)
for fila in range(longitud):
values[fila]['idItem1'] = DBSession.query(Item.nombre).filter_by(id = values[fila]['idItem1']).one()
values[fila]['idItem2'] = DBSession.query(Item.nombre).filter_by(id = values[fila]['idItem2']).one()
tmpl_context.widget = self.table
return dict(model=self.model.__name__, value_list=values)
@expose('tgext.crud.templates.get_one')
@expose('json')
def get_one(self, *args, **kw):
"""get one record, returns HTML or json"""
#this would probably only be realized as a json stream
tmpl_context.widget = self.edit_form
pks = self.provider.get_primary_fields(self.model)
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
return dict(value=value,model=self.model.__name__)
@expose('tgext.crud.templates.edit')
def edit(self, *args, **kw):
"""Display a page to edit the record."""
tmpl_context.widget = self.edit_form
#pks = self.provider.get_primary_fields(self.model)
###########################################
pks = self.provider.get_primary_fields(self.model)
###########################################
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
value['_method'] = 'PUT'
return dict(value=value, model=self.model.__name__, pk_count=len(pks))
@without_trailing_slash
@expose('sap.templates.desarrollar.relacionitem.new')
def new(self, iid=None, *args, **kw):
"""Display a page to show a new record."""
tmpl_context.widget = self.new_form
"""Fase a la cual pertenece el item que se quiere relacionar"""
faseActual = DBSession.query(Item.idFase).filter_by(id = iid).one()
"""Proyecto al cual pertenece la fase que hallamos en la linea anterior"""
proyecto = DBSession.query(Fase.idproyec).filter_by(id = faseActual).one()
listalineabase = DBSession.query(LineaBase).filter_by(idFase = faseActual).all()
desarrollo = True
longitud = len(listalineabase)
for x in range (longitud):
if str(listalineabase[x].estado).__eq__('cerrada'):
desarrollo = False
if desarrollo & longitud > 0:
fase = DBSession.query(Fase).filter_by(id = Item.idFase).first()
fase.estado = 'desarrollo'
allFaseSgte = DBSession.query(Fase).filter((Fase.idproyec == proyecto) & (Fase.id > faseActual)).all()
longFaseSgte = len(allFaseSgte)
if (longFaseSgte > 0):
allFaseSgte[0].estado = 'desarrollo'
lineabasesgte = DBSession.query(LineaBase).filter_by(idFase=allFaseSgte[0].id).all()
for x in range (len(lineabasesgte)):
if str(lineabasesgte[x].estado).__eq__('cerrada'):
lineabasesgte[x].estado = 'comprometida'
itemlbsgte = DBSession.query(Item).filter_by(idLineaBase=lineabasesgte[x].id, ultimaversion=1).all()
for y in range (len(itemlbsgte)):
itemlbsgte[y].estado = 'revision'
"""Proyecto al cual pertenece la fase que hallamos en la linea anterior"""
proyecto = DBSession.query(Fase.idproyec).filter_by(id = faseActual).one()
"""Todas las fases que pertenecen al proyecto en cuestion"""
allFase = DBSession.query(Fase).filter((Fase.idproyec == proyecto) & (Fase.id < faseActual)).all()
longFase = len(allFase)
"""Todos los item de la fase actual"""
listaActual = DBSession.query(Item.id, Item.nombre).\
filter_by(idFase=faseActual, ultimaversion=1).all()
"""Todas las relaciones existentes"""
relaciones = DBSession.query(RelacionItem.idItem1, RelacionItem.idItem2).all()
longRel = len(relaciones)
#La fase inmediatamente inferior es la fase anterior
listaAnterior=[]
#Se comprueba que exista una fase anterior
if (longFase > 0):
listaAnterior = DBSession.query(Item.id, Item.nombre).\
filter((Item.idFase==allFase[longFase-1].id) & (Item.ultimaversion==1)\
& (Item.idLineaBase != None) & (Item.estado.__eq__('aprobado'))).all()
log.debug(listaAnterior)
#Eliminar los item ya relacionados de la lista de fase anterior
for x in range(longRel):
#relaciones[x][0] = idItem1
#relaciones[x][1] = idItem2
longitud = len(listaAnterior)
if iid.__eq__("%s" %relaciones[x][0]):
for y in range(longitud):
if listaAnterior[y][0] == relaciones[x][1]:
listaAnterior.remove(listaAnterior[y])
break
elif iid.__eq__("%s" %relaciones[x][1]):
for y in range(longitud):
if listaAnterior[y][0] == relaciones[x][0]:
listaAnterior.remove(listaAnterior[y])
break
"""-----------------------------------------------"""
"""-------------------FASE ACTUAL-------------------"""
#Eliminar el item que se quiere relacionar de la lista de fase actual
longitud = len(listaActual)
for x in range(longitud):
if iid.__eq__("%s" %listaActual[x][0]):
listaActual.remove(listaActual[x])
break
#Eliminar los item ya relacionados de la lista de fase actual
for x in range(longRel):
#relaciones[x][0] = idItem1
#relaciones[x][1] = idItem2
longitud = len(listaActual)
if iid.__eq__("%s" %relaciones[x][0]):
for y in range(longitud):
if listaActual[y][0] == relaciones[x][1]:
listaActual.remove(listaActual[y])
break
self.controlCiclo (relaciones, listaActual, iid)
"""------------------------------------------------"""
#return dict(value=kw, model=self.model.__name__)
return dict(value={'idItem1':iid},
model=self.model.__name__,
actual_options=listaActual,
anterior_options=listaAnterior)
def controlCiclo (self, *args):
relaciones = args[0]
listaActual = args[1]
iid = args[2]
longRel = len(relaciones)
for x in range(longRel):
#relaciones[x][0] = idItem1
#relaciones[x][1] = idItem2
if int(iid) == int(relaciones[x][1]):
longitud = len(listaActual)
for y in range(longitud):
if listaActual[y][0] == relaciones[x][0]:
aux = listaActual[y]
self.controlCiclo(relaciones, listaActual, relaciones[x][0])
listaActual.remove(aux)
break
@catch_errors(errors, error_handler=new)
@expose()
@registered_validate(error_handler=new)
def post(self, *args, **kw):
"""Se crea un nuevo item"""
itemeditado=DBSession.query(Item).filter_by(id=kw['idItem1']).first()
itemnuevo=Item()
itemnuevo.version=itemeditado.version + 1
itemnuevo.idTipoDeItem=itemeditado.idTipoDeItem
itemnuevo.idFase=itemeditado.idFase
itemnuevo.idLineaBase=itemeditado.idLineaBase
itemnuevo.fechaCreacion=itemeditado.fechaCreacion
itemnuevo.nrohistorial=itemeditado.nrohistorial
itemnuevo.ultimaversion=1
itemeditado.ultimaversion=0
itemnuevo.estado='modificado'
itemnuevo.complejidad=itemeditado.complejidad
itemnuevo.nombre=itemeditado.nombre
DBSession.add(itemnuevo)
DBSession.flush()
"""-------------------------"""
""" Crea las nuevas relaciones"""
kw['idItem1']=itemnuevo.id
""" Se crea las relaciones"""
ids=kw['idItem2']
longitud=len(kw['idItem2'])
for indice in range(longitud):
kw['idItem2']=ids[indice]
self.provider.create(self.model, params=kw)
ids=kw['idItem2Anterior']
longitud=len(kw['idItem2Anterior'])
for indice in range(longitud):
kw['idItem2']=ids[indice]
self.provider.create(self.model, params=kw)
"""Realiza copia de los valores de los atributos especificos"""
atributoeditado=DBSession.query(DetalleItem).filter_by(iditem=itemeditado.id).all()
for objeto in atributoeditado:
nuevoDetalle=DetalleItem()
nuevoDetalle.tipo=objeto.tipo
nuevoDetalle.nombrecampo=objeto.nombrecampo
nuevoDetalle.valor=objeto.valor
nuevoDetalle.iditem=itemnuevo.id
DBSession.add(nuevoDetalle)
"""Realiza copia de los adjuntos"""
adjuntositemeditado=DBSession.query(Adjuntos).filter_by(idItem=itemeditado.id).all()
for adj in adjuntositemeditado:
itemnuevoadjunto=Adjuntos()
itemnuevoadjunto.idItem=itemnuevo.id
itemnuevoadjunto.filename=adj.filename
itemnuevoadjunto.filecontent=adj.filecontent
DBSession.add(itemnuevoadjunto)
"""Copia las relaciones """
#itemnuevo=DBSession.query(Item.id).filter_by(nrohistorial=nuevo['nrohistorial'], ultimaversion=1).first()
relaciones = DBSession.query(RelacionItem.idItem1,RelacionItem.idItem2).filter((RelacionItem.idItem2==itemeditado.id) | (RelacionItem.idItem1==itemeditado.id)).all()
longitud = len(relaciones)
for x in range(longitud):
newRelation = {}
if int(itemeditado.id) == int(relaciones[x][0]):
newRelation['idItem1']=int(itemnuevo.id)
newRelation['idItem2']=relaciones[x][1]
self.provider.create(RelacionItem, params=newRelation)
elif int(itemeditado.id) == int(relaciones[x][1]):
newRelation['idItem1']=relaciones[x][0]
newRelation['idItem2']=int(itemnuevo.id)
self.provider.create(RelacionItem, params=newRelation)
raise redirect('./?iid='+str(kw['idItem1']))
@expose()
@registered_validate(error_handler=edit)
@catch_errors(errors, error_handler=edit)
def put(self, *args, **kw):
"""update"""
pks = self.provider.get_primary_fields(self.model)
for i, pk in enumerate(pks):
if pk not in kw and i < len(args):
kw[pk] = args[i]
self.provider.update(self.model, params=kw)
redirect('../' * len(pks))
@expose()
def post_delete(self, *args, **kw):
"""This is the code that actually deletes the record"""
pks = self.provider.get_primary_fields(self.model)
d = {}
for i, arg in enumerate(args):
d[pks[i]] = arg
self.provider.delete(self.model, d)
redirect('./' + '../' * (len(pks) - 1))
@expose('tgext.crud.templates.get_delete')
def get_delete(self, *args, **kw):
"""This is the code that creates a confirm_delete page"""
return dict(args=args)
class CrudRestController(RestController):
"""
:variables:
session
database session (drives drop-down menus
menu_items
Dictionary of links to other models in the form model_items[lower_model_name] = Model
title
Title to be used for each page. default: Turbogears Admin System
:modifiers:
model
Model this class is associated with
table
Widget for the table display
table_filler
Class instance with get_value() that defines the JSon stream for the table
edit_form
Form to be used for editing the model
edit_filler
Class instance with a get_value() that defines how we get information for a single
existing record
new_form
Form that defines how we create a form for new data entry.
:Attributes:
menu_items
Dictionary of associated Models (used for menu)
provider
sprox provider for data manipulation
session
link to the database
"""
title = "Turbogears Admin System"
def _before(self, *args, **kw):
tmpl_context.title = self.title
tmpl_context.menu_items = self.menu_items
def __before__(self, *args, **kw):
# this will be removed in 2.1.*
tmpl_context.menu_items = self.menu_items
tmpl_context.title = self.title
def __init__(self, session, menu_items=None):
if menu_items is None:
menu_items = {}
self.menu_items = menu_items
self.provider = ProviderTypeSelector().get_selector(self.model).get_provider(self.model, hint=session)
self.session = session
#this makes crc declarative
check_types = ['new_form', 'edit_form', 'table', 'table_filler', 'edit_filler']
for type_ in check_types:
if not hasattr(self, type_) and hasattr(self, type_+'_type'):
setattr(self, type_, getattr(self, type_+'_type')(self.session))
if hasattr(self, 'new_form'):
#register the validators since they are none from the parent class
register_validators(self, 'post', self.new_form)
if hasattr(self, 'edit_form'):
register_validators(self, 'put', self.edit_form)
@with_trailing_slash
@expose('tgext.crud.templates.get_all')
@expose('json')
@paginate('value_list', items_per_page=7)
def get_all(self, *args, **kw):
"""Return all records.
Pagination is done by offset/limit in the filler method.
Returns an HTML page with the records if not json.
"""
if pylons.request.response_type == 'application/json':
return self.table_filler.get_value(**kw)
if not getattr(self.table.__class__, '__retrieves_own_value__', False):
values = self.table_filler.get_value(**kw)
else:
values = []
tmpl_context.widget = self.table
return dict(model=self.model.__name__, value_list=values)
@expose('tgext.crud.templates.get_one')
@expose('json')
def get_one(self, *args, **kw):
"""get one record, returns HTML or json"""
#this would probably only be realized as a json stream
tmpl_context.widget = self.edit_form
pks = self.provider.get_primary_fields(self.model)
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
return dict(value=value,model=self.model.__name__)
@expose('tgext.crud.templates.edit')
def edit(self, *args, **kw):
"""Display a page to edit the record."""
tmpl_context.widget = self.edit_form
#pks = self.provider.get_primary_fields(self.model)
log.debug("soyRomperLB= %s" %kw)
###########################################
pks = self.provider.get_primary_fields(self.model)
###########################################
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
value['_method'] = 'PUT'
return dict(value=value, model=self.model.__name__, pk_count=len(pks))
@without_trailing_slash
@expose('sap.templates.desarrollar.lineabase.new')
#@expose('tgext.crud.templates.new')
def new(self,fid=None, *args, **kw):
"""Display a page to show a new record."""
tmpl_context.widget = self.new_form
#return dict(value=kw, model=self.model.__name__)
"""obtiene los id y nombre de los items, de la fase actual """
#items = [x for x in (DBSession.query(Item.id, Item.nombre).filter_by(idFase=fid))]
itemfaseactual= [x for x in DBSession.query(Item.id, Item.nombre).filter_by(idFase=fid, idLineaBase=None, estado='aprobado', ultimaversion=1).all()]
#return dict(value={'idFase':fid}, model=self.model.__name__, item_options=items)
longitud=len(itemfaseactual)
if (longitud == 0):
flash("No existen items aprobados en la fase actual", "error")
redirect('../?fid='+fid)
else:
return dict(value={'idFase':fid}, model=self.model.__name__, items_options=itemfaseactual)
@catch_errors(errors, error_handler=new)
@expose()
@registered_validate(error_handler=new)
def post(self, *args, **kw):
ids=kw['items']
longitud = len(ids)
items = DBSession.query(Item).filter_by(idFase=kw['idFase'], ultimaversion=1).all()
if (longitud > 0):
fase = DBSession.query(Fase).filter_by(id=kw['idFase']).first()
if longitud == len(items):
fase.estado = 'lineaBaseTotal'
else:
fase.estado = 'lineaBaseParcial'
lineabase = self.provider.create(self.model, params=kw)
for indice in range(longitud):
item = DBSession.query(Item).filter_by(id=ids[indice]).first()
item.idLineaBase = lineabase.id
raise redirect('./?fid='+kw['idFase'])
else:
flash("No ha seleccionado ningun item", "error")
raise redirect('./new/?fid='+kw['idFase'])
@expose()
@registered_validate(error_handler=edit)
@catch_errors(errors, error_handler=edit)
def put(self, *args, **kw):
"""update"""
pks = self.provider.get_primary_fields(self.model)
for i, pk in enumerate(pks):
if pk not in kw and i < len(args):
kw[pk] = args[i]
log.debug('putLineaBase= %s' %kw)
#lineabase/?fid=21
self.provider.update(self.model, params=kw)
redirect('../' + '../lineabase/?fid=' + str(kw['idFase']))
@expose()
def post_delete(self, *args, **kw):
"""This is the code that actually deletes the record"""
pks = self.provider.get_primary_fields(self.model)
d = {}
for i, arg in enumerate(args):
d[pks[i]] = arg
"""extraer el idFase para poder retornar en el estado anterior """
idfase= DBSession.query(LineaBase.idFase).filter_by(id=d['id']).first()
self.provider.delete(self.model, d)
redirect('/lineabase/?fid='+str(idfase[0]))
@expose('tgext.crud.templates.get_delete')
def get_delete(self, *args, **kw):
"""This is the code that creates a confirm_delete page"""
return dict(args=args)
def setup(self):
self.type_selector = ProviderTypeSelector()
class CrudRestController(RestController):
"""
:variables:
session
database session (drives drop-down menus
menu_items
Dictionary of links to other models in the form model_items[lower_model_name] = Model
title
Title to be used for each page. default: Turbogears Admin System
:modifiers:
model
Model this class is associated with
table
Widget for the table display
table_filler
Class instance with get_value() that defines the JSon stream for the table
edit_form
Form to be used for editing the model
edit_filler
Class instance with a get_value() that defines how we get information for a single
existing record
new_form
Form that defines how we create a form for new data entry.
:Attributes:
menu_items
Dictionary of associated Models (used for menu)
provider
sprox provider for data manipulation
session
link to the database
"""
title = "Turbogears Admin System"
def _before(self, *args, **kw):
tmpl_context.title = self.title
tmpl_context.menu_items = self.menu_items
def __before__(self, *args, **kw):
# this will be removed in 2.1.*
tmpl_context.menu_items = self.menu_items
tmpl_context.title = self.title
def __init__(self, session, menu_items=None):
if menu_items is None:
menu_items = {}
self.menu_items = menu_items
self.provider = ProviderTypeSelector().get_selector(self.model).get_provider(self.model, hint=session)
self.session = session
#this makes crc declarative
check_types = ['new_form', 'edit_form', 'table', 'table_filler', 'edit_filler']
for type_ in check_types:
if not hasattr(self, type_) and hasattr(self, type_+'_type'):
setattr(self, type_, getattr(self, type_+'_type')(self.session))
if hasattr(self, 'new_form'):
#register the validators since they are none from the parent class
register_validators(self, 'post', self.new_form)
if hasattr(self, 'edit_form'):
register_validators(self, 'put', self.edit_form)
@with_trailing_slash
@expose('tgext.crud.templates.get_all')
@expose('json')
@paginate('value_list', items_per_page=7)
def get_all(self, *args, **kw):
"""Return all records.
Pagination is done by offset/limit in the filler method.
Returns an HTML page with the records if not json.
"""
if pylons.request.response_type == 'application/json':
return self.table_filler.get_value(**kw)
if not getattr(self.table.__class__, '__retrieves_own_value__', False):
values = self.table_filler.get_value(**kw)
else:
values = []
tmpl_context.widget = self.table
return dict(model=self.model.__name__, value_list=values)
@expose('tgext.crud.templates.get_one')
@expose('json')
def get_one(self, *args, **kw):
"""get one record, returns HTML or json"""
#this would probably only be realized as a json stream
tmpl_context.widget = self.edit_form
pks = self.provider.get_primary_fields(self.model)
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
return dict(value=value,model=self.model.__name__)
@expose('tgext.crud.templates.edit')
def edit(self, *args, **kw):
"""Display a page to edit the record."""
tmpl_context.widget = self.edit_form
#pks = self.provider.get_primary_fields(self.model)
###########################################
pks = self.provider.get_primary_fields(self.model)
###########################################
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
value['_method'] = 'PUT'
return dict(value=value, model=self.model.__name__, pk_count=len(pks))
@without_trailing_slash
@expose('sap.templates.desarrollar.adjuntos.new')
def new(self,iid=None ,*args, **kw):
"""Aqui entra solo para mostrar la vista y para guardar, el descargar
borrar esta implementado en root"""
log.debug('iid: %s' %iid)
log.debug('adjuntos: %s' %kw)
longitud=len(kw)
log.debug('longitud: %s' %longitud)
if longitud==0:
#current_files = DBSession.query(Adjuntos).all()
current_files = DBSession.query(Adjuntos).filter_by(idItem=iid).all()
return dict(current_files=current_files, model=self.model.__name__,iid=iid)
else:
if iid=="save":
iid=kw['idItem']
idItem=kw['idItem']
userfile=kw['userfile']
log.debug('idItem: %s' %idItem)
if userfile=='':
flash("No ha selecionado ningun archivo", "error")
redirect("../new/?iid="+str(iid))
"""
forbidden_files = [".js", ".htm", ".html"]
for forbidden_file in forbidden_files:
if userfile.filename.find(forbidden_file) != -1:
return redirect("../adjuntos/new")
filecontent = userfile.file.read()
new_file = Adjuntos(filename=userfile.filename, filecontent=filecontent,idItem=idItem )
DBSession.add(new_file)
DBSession.flush()
"""
"""Realiza una copia del item cuando se adjunta un archivo y aumenta su version"""
itemeditado= DBSession.query(Item).filter_by(id=idItem).first()
itemnuevo=Item()
itemnuevo.version=itemeditado.version + 1
itemnuevo.idTipoDeItem=itemeditado.idTipoDeItem
itemnuevo.idFase=itemeditado.idFase
itemnuevo.idLineaBase=itemeditado.idLineaBase
itemnuevo.fechaCreacion=itemeditado.fechaCreacion
itemnuevo.nrohistorial=itemeditado.nrohistorial
itemnuevo.ultimaversion=1
itemeditado.ultimaversion=0
itemnuevo.estado='modificado'
itemnuevo.complejidad=itemeditado.complejidad
itemnuevo.nombre=itemeditado.nombre
DBSession.add(itemnuevo)
"""Realiza copia de los valores de los atributos especificos"""
atributoeditado=DBSession.query(DetalleItem).filter_by(iditem=itemeditado.id).all()
for objeto in atributoeditado:
nuevoDetalle=DetalleItem()
nuevoDetalle.tipo=objeto.tipo
nuevoDetalle.nombrecampo=objeto.nombrecampo
nuevoDetalle.valor=objeto.valor
nuevoDetalle.iditem=itemnuevo.id
DBSession.add(nuevoDetalle)
"""Copia las relaciones """
relaciones = DBSession.query(RelacionItem.idItem1,RelacionItem.idItem2).filter((RelacionItem.idItem2==itemeditado.id) | (RelacionItem.idItem1==itemeditado.id)).all()
longitud = len(relaciones)
for x in range(longitud):
newRelation=RelacionItem()
log.debug('Creando relaciones')
if int(itemeditado.id) == int(relaciones[x][0]):
newRelation.idItem1=int(itemnuevo.id)
newRelation.idItem2=relaciones[x][1]
DBSession.add(newRelation)
#self.provider.create(RelacionItem, params=newRelation)
elif int(itemeditado.id) == int(relaciones[x][1]):
newRelation.idItem1=relaciones[x][0]
newRelation.idItem2=int(itemnuevo.id)
DBSession.add(newRelation)
"""Realiza copia de los adjuntos"""
adjuntositemeditado=DBSession.query(Adjuntos).filter_by(idItem=itemeditado.id).all()
for adj in adjuntositemeditado:
itemnuevoadjunto=Adjuntos()
log.debug("adj: %s" %adj)
itemnuevoadjunto=Adjuntos()
itemnuevoadjunto.idItem=itemnuevo.id
itemnuevoadjunto.filename=adj.filename
itemnuevoadjunto.filecontent=adj.filecontent
DBSession.add(itemnuevoadjunto)
forbidden_files = [".js", ".htm", ".html"]
for forbidden_file in forbidden_files:
if userfile.filename.find(forbidden_file) != -1:
return redirect("../adjuntos/new")
filecontent = userfile.file.read()
log.debug('itemnuevo: %s' %itemnuevo.id)
new_file = Adjuntos(filename=userfile.filename, filecontent=filecontent,idItem=itemnuevo.id )
DBSession.add(new_file)
#DBSession.flush()
#self.provider.create(self.model, params=nuevo)
log.debug('adjuntositemeditado: %s' %adjuntositemeditado)
redirect("../new/?iid="+str(itemnuevo.id))
#return dict(current_files=current_files ,model=self.model.__name__,iid=iid)
#tmpl_context.widget = self.new_form
#return dict(value=kw, model=self.model.__name__)
@catch_errors(errors, error_handler=new)
@expose()
@registered_validate(error_handler=new)
def post(self, *args, **kw):
userfile=kw['userfile']
log.debug("kwwww: %s" %kw)
forbidden_files = [".js", ".htm", ".html"]
for forbidden_file in forbidden_files:
if userfile.filename.find(forbidden_file) != -1:
return redirect("/adjuntos/new")
filecontent = userfile.file.read()
new_file = Adjuntos(filename=userfile.filename, filecontent=filecontent)
DBSession.add(new_file)
DBSession.flush()
redirect("/adjuntos/new")
#self.provider.create(self.model, params=kw)
raise redirect('/adjuntos/new')
@expose()
@registered_validate(error_handler=edit)
@catch_errors(errors, error_handler=edit)
def put(self, *args, **kw):
"""update"""
pks = self.provider.get_primary_fields(self.model)
for i, pk in enumerate(pks):
if pk not in kw and i < len(args):
kw[pk] = args[i]
self.provider.update(self.model, params=kw)
redirect('../' * len(pks))
@expose()
def post_delete(self, *args, **kw):
"""
pks = self.provider.get_primary_fields(self.model)
d = {}
for i, arg in enumerate(args):
d[pks[i]] = arg
self.provider.delete(self.model, d)
redirect('./' + '../' * (len(pks) - 1))
"""
log.debug("Estoy en el PostDelete")
"""
def delete(self, fileid):
try:
userfile = DBSession.query(Adjuntos).filter_by(id=fileid).one()
except:
return redirect("/adjuntos/new")
DBSession.delete(userfile)
return redirect("/adjuntos/new")
"""
return redirect("/adjuntos/new")
@expose('tgext.crud.templates.get_delete')
def get_delete(self, *args, **kw):
"""This is the code that creates a confirm_delete page"""
return dict(args=args)
class CrudRestController(RestController):
"""
:variables:
session
database session (drives drop-down menus
menu_items
Dictionary of links to other models in the form model_items[lower_model_name] = Model
title
Title to be used for each page. default: Turbogears Admin System
:modifiers:
model
Model this class is associated with
table
Widget for the table display
table_filler
Class instance with get_value() that defines the JSon stream for the table
edit_form
Form to be used for editing the model
edit_filler
Class instance with a get_value() that defines how we get information for a single
existing record
new_form
Form that defines how we create a form for new data entry.
:Attributes:
menu_items
Dictionary of associated Models (used for menu)
provider
sprox provider for data manipulation
session
link to the database
"""
title = "Turbogears Admin System"
def _before(self, *args, **kw):
tmpl_context.title = self.title
tmpl_context.menu_items = self.menu_items
def __before__(self, *args, **kw):
# this will be removed in 2.1.*
tmpl_context.menu_items = self.menu_items
tmpl_context.title = self.title
def __init__(self, session, menu_items=None):
if menu_items is None:
menu_items = {}
self.menu_items = menu_items
self.provider = ProviderTypeSelector().get_selector(self.model).get_provider(self.model, hint=session)
self.session = session
#this makes crc declarative
check_types = ['new_form', 'edit_form', 'table', 'table_filler', 'edit_filler']
for type_ in check_types:
if not hasattr(self, type_) and hasattr(self, type_+'_type'):
setattr(self, type_, getattr(self, type_+'_type')(self.session))
if hasattr(self, 'new_form'):
#register the validators since they are none from the parent class
register_validators(self, 'post', self.new_form)
if hasattr(self, 'edit_form'):
register_validators(self, 'put', self.edit_form)
@with_trailing_slash
@expose('tgext.crud.templates.get_all')
@expose('json')
@paginate('value_list', items_per_page=7)
def get_all(self, *args, **kw):
"""Return all records.
Pagination is done by offset/limit in the filler method.
Returns an HTML page with the records if not json.
"""
if pylons.request.response_type == 'application/json':
return self.table_filler.get_value(**kw)
if not getattr(self.table.__class__, '__retrieves_own_value__', False):
values = self.table_filler.get_value(**kw)
else:
values = []
longitud=len(values)
for fila in range(longitud):
values[fila]['idProyecto'] = DBSession.query(Proyecto.nombre).filter_by(id = values[fila]['idProyecto']).one()
values[fila]['idFase'] = DBSession.query(Fase.nombre).filter_by(id = values[fila]['idFase']).one()
values[fila]['iduser'] = DBSession.query(User.user_name).filter_by(user_id = values[fila]['iduser']).one()
values[fila]['idPermiso'] = DBSession.query(Permission.permission_name).filter_by(permission_id = values[fila]['idPermiso']).one()
tmpl_context.widget = self.table
return dict(model=self.model.__name__, value_list=values)
@expose('tgext.crud.templates.get_one')
@expose('json')
def get_one(self, *args, **kw):
"""get one record, returns HTML or json"""
#this would probably only be realized as a json stream
tmpl_context.widget = self.edit_form
pks = self.provider.get_primary_fields(self.model)
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
return dict(value=value,model=self.model.__name__)
@expose('tgext.crud.templates.edit')
def edit(self, *args, **kw):
"""Display a page to edit the record."""
tmpl_context.widget = self.edit_form
pks = self.provider.get_primary_fields(self.model)
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
value['_method'] = 'PUT'
return dict(value=value, model=self.model.__name__, pk_count=len(pks))
@without_trailing_slash
@expose('sap.templates.configurar.proyfaseusuario.new')
def new(self,pid=None ,*args, **kw):
"""Display a page to show a new record."""
tmpl_context.widget = self.new_form
fases = [x for x in DBSession.query(Fase.id, Fase.nombre).filter_by(idproyec=pid)]
usuarios = [x for x in (DBSession.query(User.user_id, User.user_name))]
usuarios.remove(usuarios[0])
#permisos= [x for x in (DBSession.query(Permission. permission_id ,Permission. permission_name))]
return dict(value={'idProyecto':pid}, model=self.model.__name__, fases_options=fases, usuarios_options=usuarios)
@catch_errors(errors, error_handler=new)
@expose()
@registered_validate(error_handler=new)
def post(self, *args, **kw):
ids= kw['idPermiso']
longitud= len(kw['idPermiso'])
for indice in range(longitud):
kw['idPermiso']= ids[indice]
msj=DBSession.query(ProyFaseUsuario).filter_by(idProyecto=kw['idProyecto'], iduser=kw['iduser'], idFase=kw['idFase'],idPermiso=kw['idPermiso']).first()
log.debug('msg: %s' %msj)
if msj == None:
self.provider.create(self.model, params=kw)
else:
flash("El usuario ya fue adherido a la Fase elegida", "error")
redirect('new/?pid='+ kw['idProyecto'])
raise redirect('./?pid='+ kw['idProyecto'])
@expose()
@registered_validate(error_handler=edit)
@catch_errors(errors, error_handler=edit)
def put(self, *args, **kw):
"""update"""
pks = self.provider.get_primary_fields(self.model)
for i, pk in enumerate(pks):
if pk not in kw and i < len(args):
kw[pk] = args[i]
self.provider.update(self.model, params=kw)
redirect('../' * len(pks))
@expose()
def post_delete(self, *args, **kw):
"""This is the code that actually deletes the record"""
pks = self.provider.get_primary_fields(self.model)
d = {}
for i, arg in enumerate(args):
d[pks[i]] = arg
self.provider.delete(self.model, d)
#redirect('./' + '../' * (len(pks) - 1))
redirect('../../../?pid='+ d['idProyecto'])
@expose('tgext.crud.templates.get_delete')
def get_delete(self, *args, **kw):
"""This is the code that creates a confirm_delete page"""
return dict(args=args)
class CrudRestController(RestController):
"""
:initialization options:
**session**
database session
**menu_items**
Dictionary or mapping type of links to other CRUD sections.
This is used to generate the links sidebar of the CRUD interface.
Can be specified in the form ``model_items['lower_model_name'] = ModelClass`` or
``model_items['link'] = 'Name'``.
:class attributes:
**title**
Title to be used for each page. default: ``'Turbogears Admin System'``
**model**
Model this class is associated with.
**remember_values**
List of model attributes that need to keep previous value when not provided
on submission instead of replacing the existing value with an empty one.
It's commonly used with file fields to avoid having to reupload the file
again when the model is edited.
**keep_params**
List of URL parameters that need to be kept around when redirecting between
the various pages of the CRUD controller. Can be used to keep around filters
or sorting when editing a subset of the models.
**search_fields**
Enables searching on some fields, can be ``True``, ``False`` or a list
of fields for which searching should be enabled.
**substring_filters**
Enable substring filtering for some fields, by default is disabled.
Pass ``True`` to enable it on all fields or pass a list of field
names to enable it only on some fields.
**json_dictify**
``True`` or ``False``, enables advanced dictification of retrieved models
when providing JSON responses. This also enables JSON encoding of related entities
for the returned model.
**conditional_update_field**
Name of the field used to perform conditional updates when ``PUT`` method is
used as a REST API. ``None`` disables conditional updates (which is the default).
**pagination**
Dictionary of options for pagination. ``False`` disables pagination.
By default ``{'items_per_page': 7}`` is provided.
Currently the only supported option is ``items_per_page``.
**response_type**
Limit response to a single format, can be: 'application/json' or 'text/html'.
By default tgext.crud will detect expected response from Accept header and
will provide response content according to the expected one. If you want
to avoid HTML access to a plain JSON API you can use this option to limit
valid responses to application/json.
**resources**
A list of CSSSource / JSSource that have to be injected inside CRUD
pages when rendering. By default ``tgext.crud.resources.crud_style`` and
``tgext.crud.resources.crud_script`` are injected.
**table**
The ``sprox.tablebase.TableBase`` Widget instance used to display the table.
By default ``tgext.crud.utils.SortableTableBase`` is used which permits to sort
table by columns.
**table_filler**
The ``sprox.fillerbase.TableFiller`` instance used to retrieve data for the table.
If you want to customize how data is retrieved override the
``TableFiller._do_get_provider_count_and_objs`` method to return different entities and count.
By default ``tgext.crud.utils.RequestLocalTableFiller`` is used which keeps
track of the numer of entities retrieved during the current request to enable pagination.
**edit_form**
Form to be used for editing an existing model.
By default ``sprox.formbase.EditForm`` is used.
**edit_filler**
``sprox.fillerbase.RecordFiller`` subclass used to load the values for
an entity that need to be edited. Override the ``RecordFiller.get_value``
method to provide custom values.
**new_form**
Form that defines how to create a new model.
By default ``sprox.formbase.AddRecordForm`` is used.
"""
title = "Turbogears Admin System"
keep_params = None
remember_values = []
substring_filters = []
search_fields = True # True for automagic
json_dictify = False # True is slower but provides relations
conditional_update_field = None
response_type = None
pagination = {'items_per_page': 7}
resources = (crud_style, crud_script)
def _before(self, *args, **kw):
tmpl_context.title = self.title
tmpl_context.menu_items = self.menu_items
tmpl_context.kept_params = self._kept_params()
tmpl_context.crud_helpers = self.helpers
for resource in self.resources:
resource.inject()
force_response_type(self.response_type)
__before__ = _before #This can be removed since 2.2
def _mount_point(self):
try:
mount_point = self.mount_point
except:
mount_point = None
if not mount_point:
#non statically mounted or Old TurboGears, use relative URL
mount_point = '.'
return mount_point
def _kept_params(self):
if not self.keep_params:
return {}
if not request.referer:
from_referer = {}
else:
parsed = url_parse(request.referer)
from_referer = dict(cgi.parse_qsl(parsed.query))
from_referer.update(request.params)
pass_params = {}
for k in self.keep_params:
if k in from_referer:
pass_params[k] = from_referer[k]
return pass_params
def _adapt_menu_items(self, menu_items):
adapted_menu_items = type(menu_items)()
for link, model in menu_items.items():
if inspect.isclass(model):
adapted_menu_items[link + 's'] = model.__name__
else:
adapted_menu_items[link] = model
return adapted_menu_items
def _get_search_fields(self, kw):
if self.search_fields is True:
return [(field, self.table.__headers__.get(field, field),
kw.get(field, False)) for field in self.table.__fields__
if field != '__actions__']
elif self.search_fields:
# This allows for customizing the search fields to be shown in the table definition
# search_fields can be either a list of tuples with (field, name) or just a string field = name
search_fields = []
for field in self.search_fields:
if isinstance(field, string_type):
search_fields.append((field, field, kw.get(field, False)))
else:
search_fields.append(
(field[0], field[1], kw.get(field[0], False)))
return search_fields
else:
# This would be where someone explicitly disabled the search functionality
return []
def _get_current_search(self, search_fields):
if not search_fields:
return None
for field, _, value in search_fields:
if value is not False:
return (field, value)
return (search_fields[0][0], '')
def _dictify(self, value, length=None):
json_dictify = self.json_dictify
if json_dictify is False:
return value
def _dictify(entity):
if hasattr(entity, '__json__'):
return entity.__json__()
else:
return self.provider.dictify(entity, **json_dictify)
if length is not None:
#return a generator, we don't want to consume the whole query if it is paginated
return (_dictify(entity) for entity in value)
else:
return _dictify(value)
def __init__(self, session, menu_items=None):
if hasattr(self, 'style'):
warnings.warn(
'style attribute is not supported anymore, '
'resources attribute replaces it',
DeprecationWarning,
stacklevel=2)
self.resources = (crud_script,
CSSSource(location='headbottom', src=self.style))
if menu_items is None:
menu_items = {}
self.menu_items = self._adapt_menu_items(menu_items)
self.helpers = CrudRestControllerHelpers()
self.provider = ProviderTypeSelector().get_selector(
self.model).get_provider(self.model, hint=session)
self.session = session
if self.json_dictify is True:
self.json_dictify = {}
#this makes crc declarative
check_types = [
'new_form', 'edit_form', 'table', 'table_filler', 'edit_filler'
]
for type_ in check_types:
if not hasattr(self, type_) and hasattr(self, type_ + '_type'):
setattr(self, type_,
getattr(self, type_ + '_type')(self.session))
# Enable pagination only if table_filler has support for request local __count__
self.pagination_enabled = (self.pagination and isinstance(
self.table_filler, RequestLocalTableFiller))
if hasattr(self, 'new_form'):
#register the validators since they are none from the parent class
register_validators(self, 'post', self.new_form)
if hasattr(self, 'edit_form'):
register_validators(self, 'put', self.edit_form)
@with_trailing_slash
@expose('genshi:tgext.crud.templates.get_all')
@expose('mako:tgext.crud.templates.get_all')
@expose('jinja:tgext.crud.templates.get_all')
@expose('json:')
@optional_paginate('value_list')
def get_all(self, *args, **kw):
"""Return all records.
Pagination is done by offset/limit in the filler method.
Returns an HTML page with the records if not json.
"""
if self.pagination:
paginator = request.paginators['value_list']
paginator.paginate_items_per_page = self.pagination[
'items_per_page']
else:
paginator = request.paginators['value_list']
paginator.paginate_items_per_page = -1
paginator.paginate_page = 0
if tg.request.response_type == 'application/json':
adapt_params_for_pagination(kw, self.pagination_enabled)
try:
count, values = self.table_filler._do_get_provider_count_and_objs(
**kw)
except Exception as e:
abort(400, detail=unicode_text(e))
values = self._dictify(values, length=count)
if self.pagination_enabled:
values = SmartPaginationCollection(values, count)
return dict(value_list=values)
if not getattr(self.table.__class__, '__retrieves_own_value__', False):
kw.pop('substring_filters', None)
if self.substring_filters is True:
substring_filters = list(
set(kw.keys()) -
set(['limit', 'offset', 'order_by', 'desc']))
else:
substring_filters = self.substring_filters
adapt_params_for_pagination(kw, self.pagination_enabled)
try:
values = self.table_filler.get_value(
substring_filters=substring_filters, **kw)
except Exception as e:
flash(
'Invalid search query "%s": %s' %
(request.query_string, e), 'warn')
# Reset all variables to sane defaults
kw = {}
values = []
self.table_filler.__count__ = 0
if self.pagination_enabled:
values = SmartPaginationCollection(values,
self.table_filler.__count__)
else:
values = []
tmpl_context.widget = self.table
search_fields = self._get_search_fields(kw)
current_search = self._get_current_search(search_fields)
return dict(
model=self.model.__name__,
value_list=values,
mount_point=self._mount_point(),
headers=search_fields, # Just for backwards compatibility
search_fields=search_fields,
current_search=current_search)
@expose('genshi:tgext.crud.templates.get_one')
@expose('mako:tgext.crud.templates.get_one')
@expose('jinja:tgext.crud.templates.get_one')
@expose('json:')
def get_one(self, *args, **kw):
"""get one record, returns HTML or json"""
#this would probably only be realized as a json stream
kw = map_args_to_pks(args, {})
if tg.request.response_type == 'application/json':
obj = self.provider.get_obj(self.model, kw)
if obj is None:
tg.response.status_code = 404
elif self.conditional_update_field is not None:
tg.response.last_modified = getattr(
obj, self.conditional_update_field)
return dict(model=self.model.__name__, value=self._dictify(obj))
tmpl_context.widget = self.edit_form
value = self.edit_filler.get_value(kw)
return dict(value=value, model=self.model.__name__)
@expose('genshi:tgext.crud.templates.edit')
@expose('mako:tgext.crud.templates.edit')
@expose('jinja:tgext.crud.templates.edit')
def edit(self, *args, **kw):
"""Display a page to edit the record."""
pks = self.provider.get_primary_fields(self.model)
kw = map_args_to_pks(args, {})
tmpl_context.widget = self.edit_form
value = self.edit_filler.get_value(kw)
value['_method'] = 'PUT'
return dict(value=value, model=self.model.__name__, pk_count=len(pks))
@without_trailing_slash
@expose('genshi:tgext.crud.templates.new')
@expose('mako:tgext.crud.templates.new')
@expose('jinja:tgext.crud.templates.new')
def new(self, *args, **kw):
"""Display a page to show a new record."""
tmpl_context.widget = self.new_form
return dict(value=kw, model=self.model.__name__)
@expose(content_type='text/html')
@expose('json:', content_type='application/json')
@before_validate(allow_json_parameters)
@catch_errors(errors, error_handler=new)
@registered_validate(error_handler=new)
def post(self, *args, **kw):
obj = self.provider.create(self.model, params=kw)
if tg.request.response_type == 'application/json':
if obj is not None and self.conditional_update_field is not None:
tg.response.last_modified = getattr(
obj, self.conditional_update_field)
return dict(model=self.model.__name__, value=self._dictify(obj))
return redirect('./', params=self._kept_params())
@expose(content_type='text/html')
@expose('json:', content_type='application/json')
@before_validate(allow_json_parameters)
@before_validate(map_args_to_pks)
@registered_validate(error_handler=edit)
@catch_errors(errors, error_handler=edit)
def put(self, *args, **kw):
"""update"""
omit_fields = []
if getattr(self, 'edit_form', None):
omit_fields.extend(self.edit_form.__omit_fields__)
for remembered_value in self.remember_values:
value = kw.get(remembered_value)
if value is None or value == '':
omit_fields.append(remembered_value)
obj = self.provider.get_obj(self.model, kw)
#This should actually by done by provider.update to make it atomic
can_modify = True
if obj is not None and self.conditional_update_field is not None and \
tg.request.if_unmodified_since is not None and \
tg.request.if_unmodified_since < getattr(obj, self.conditional_update_field):
can_modify = False
if obj is not None and can_modify:
obj = self.provider.update(self.model,
params=kw,
omit_fields=omit_fields)
if tg.request.response_type == 'application/json':
if obj is None:
tg.response.status_code = 404
elif can_modify is False:
tg.response.status_code = 412
elif self.conditional_update_field is not None:
tg.response.last_modified = getattr(
obj, self.conditional_update_field)
return dict(model=self.model.__name__, value=self._dictify(obj))
pks = self.provider.get_primary_fields(self.model)
return redirect('../' * len(pks), params=self._kept_params())
@expose(content_type='text/html')
@expose('json:', content_type='application/json')
def post_delete(self, *args, **kw):
"""This is the code that actually deletes the record"""
kw = map_args_to_pks(args, {})
obj = None
if kw:
obj = self.provider.get_obj(self.model, kw)
if obj is not None:
self.provider.delete(self.model, kw)
if tg.request.response_type == 'application/json':
return dict()
pks = self.provider.get_primary_fields(self.model)
return redirect('./' + '../' * (len(pks) - 1),
params=self._kept_params())
@expose('genshi:tgext.crud.templates.get_delete')
@expose('jinja:tgext.crud.templates.get_delete')
def get_delete(self, *args, **kw):
"""This is the code that creates a confirm_delete page"""
return dict(args=args)
class CrudRestController(RestController):
"""
:variables:
session
database session (drives drop-down menus
menu_items
Dictionary of links to other models in the form model_items[lower_model_name] = Model
title
Title to be used for each page. default: Turbogears Admin System
:modifiers:
model
Model this class is associated with
table
Widget for the table display
table_filler
Class instance with get_value() that defines the JSon stream for the table
edit_form
Form to be used for editing the model
edit_filler
Class instance with a get_value() that defines how we get information for a single
existing record
new_form
Form that defines how we create a form for new data entry.
:Attributes:
menu_items
Dictionary of associated Models (used for menu)
provider
sprox provider for data manipulation
session
link to the database
"""
title = "Turbogears Admin System"
def _before(self, *args, **kw):
tmpl_context.title = self.title
tmpl_context.menu_items = self.menu_items
def __before__(self, *args, **kw):
# this will be removed in 2.1.*
tmpl_context.menu_items = self.menu_items
tmpl_context.title = self.title
def __init__(self, session, menu_items=None):
if menu_items is None:
menu_items = {}
self.menu_items = menu_items
self.provider = ProviderTypeSelector().get_selector(
self.model).get_provider(self.model, hint=session)
self.session = session
#this makes crc declarative
check_types = [
'new_form', 'edit_form', 'table', 'table_filler', 'edit_filler'
]
for type_ in check_types:
if not hasattr(self, type_) and hasattr(self, type_ + '_type'):
setattr(self, type_,
getattr(self, type_ + '_type')(self.session))
if hasattr(self, 'new_form'):
#register the validators since they are none from the parent class
register_validators(self, 'post', self.new_form)
if hasattr(self, 'edit_form'):
register_validators(self, 'put', self.edit_form)
@with_trailing_slash
@expose('tgext.crud.templates.get_all')
@expose('json')
@paginate('value_list', items_per_page=7)
def get_all(self, *args, **kw):
"""Return all records.
Pagination is done by offset/limit in the filler method.
Returns an HTML page with the records if not json.
"""
if pylons.request.response_type == 'application/json':
return self.table_filler.get_value(**kw)
if not getattr(self.table.__class__, '__retrieves_own_value__', False):
values = self.table_filler.get_value(**kw)
else:
values = []
tmpl_context.widget = self.table
return dict(model=self.model.__name__, value_list=values)
@expose('tgext.crud.templates.get_one')
@expose('json')
def get_one(self, *args, **kw):
"""get one record, returns HTML or json"""
#this would probably only be realized as a json stream
tmpl_context.widget = self.edit_form
pks = self.provider.get_primary_fields(self.model)
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
return dict(value=value, model=self.model.__name__)
@expose('tgext.crud.templates.edit')
def edit(self, *args, **kw):
"""Display a page to edit the record."""
tmpl_context.widget = self.edit_form
#pks = self.provider.get_primary_fields(self.model)
###########################################
pks = self.provider.get_primary_fields(self.model)
###########################################
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
value['_method'] = 'PUT'
return dict(value=value, model=self.model.__name__, pk_count=len(pks))
@without_trailing_slash
@expose('sap.templates.desarrollar.adjuntos.new')
def new(self, iid=None, *args, **kw):
"""Aqui entra solo para mostrar la vista y para guardar, el descargar
borrar esta implementado en root"""
log.debug('iid: %s' % iid)
log.debug('adjuntos: %s' % kw)
longitud = len(kw)
log.debug('longitud: %s' % longitud)
if longitud == 0:
#current_files = DBSession.query(Adjuntos).all()
current_files = DBSession.query(Adjuntos).filter_by(
idItem=iid).all()
return dict(current_files=current_files,
model=self.model.__name__,
iid=iid)
else:
if iid == "save":
iid = kw['idItem']
idItem = kw['idItem']
userfile = kw['userfile']
log.debug('idItem: %s' % idItem)
if userfile == '':
flash("No ha selecionado ningun archivo", "error")
redirect("../new/?iid=" + str(iid))
"""
forbidden_files = [".js", ".htm", ".html"]
for forbidden_file in forbidden_files:
if userfile.filename.find(forbidden_file) != -1:
return redirect("../adjuntos/new")
filecontent = userfile.file.read()
new_file = Adjuntos(filename=userfile.filename, filecontent=filecontent,idItem=idItem )
DBSession.add(new_file)
DBSession.flush()
"""
"""Realiza una copia del item cuando se adjunta un archivo y aumenta su version"""
itemeditado = DBSession.query(Item).filter_by(id=idItem).first()
itemnuevo = Item()
itemnuevo.version = itemeditado.version + 1
itemnuevo.idTipoDeItem = itemeditado.idTipoDeItem
itemnuevo.idFase = itemeditado.idFase
itemnuevo.idLineaBase = itemeditado.idLineaBase
itemnuevo.fechaCreacion = itemeditado.fechaCreacion
itemnuevo.nrohistorial = itemeditado.nrohistorial
itemnuevo.ultimaversion = 1
itemeditado.ultimaversion = 0
itemnuevo.estado = 'modificado'
itemnuevo.complejidad = itemeditado.complejidad
itemnuevo.nombre = itemeditado.nombre
DBSession.add(itemnuevo)
"""Realiza copia de los valores de los atributos especificos"""
atributoeditado = DBSession.query(DetalleItem).filter_by(
iditem=itemeditado.id).all()
for objeto in atributoeditado:
nuevoDetalle = DetalleItem()
nuevoDetalle.tipo = objeto.tipo
nuevoDetalle.nombrecampo = objeto.nombrecampo
nuevoDetalle.valor = objeto.valor
nuevoDetalle.iditem = itemnuevo.id
DBSession.add(nuevoDetalle)
"""Copia las relaciones """
relaciones = DBSession.query(
RelacionItem.idItem1, RelacionItem.idItem2).filter(
(RelacionItem.idItem2 == itemeditado.id)
| (RelacionItem.idItem1 == itemeditado.id)).all()
longitud = len(relaciones)
for x in range(longitud):
newRelation = RelacionItem()
log.debug('Creando relaciones')
if int(itemeditado.id) == int(relaciones[x][0]):
newRelation.idItem1 = int(itemnuevo.id)
newRelation.idItem2 = relaciones[x][1]
DBSession.add(newRelation)
#self.provider.create(RelacionItem, params=newRelation)
elif int(itemeditado.id) == int(relaciones[x][1]):
newRelation.idItem1 = relaciones[x][0]
newRelation.idItem2 = int(itemnuevo.id)
DBSession.add(newRelation)
"""Realiza copia de los adjuntos"""
adjuntositemeditado = DBSession.query(Adjuntos).filter_by(
idItem=itemeditado.id).all()
for adj in adjuntositemeditado:
itemnuevoadjunto = Adjuntos()
log.debug("adj: %s" % adj)
itemnuevoadjunto = Adjuntos()
itemnuevoadjunto.idItem = itemnuevo.id
itemnuevoadjunto.filename = adj.filename
itemnuevoadjunto.filecontent = adj.filecontent
DBSession.add(itemnuevoadjunto)
forbidden_files = [".js", ".htm", ".html"]
for forbidden_file in forbidden_files:
if userfile.filename.find(forbidden_file) != -1:
return redirect("../adjuntos/new")
filecontent = userfile.file.read()
log.debug('itemnuevo: %s' % itemnuevo.id)
new_file = Adjuntos(filename=userfile.filename,
filecontent=filecontent,
idItem=itemnuevo.id)
DBSession.add(new_file)
#DBSession.flush()
#self.provider.create(self.model, params=nuevo)
log.debug('adjuntositemeditado: %s' % adjuntositemeditado)
redirect("../new/?iid=" + str(itemnuevo.id))
#return dict(current_files=current_files ,model=self.model.__name__,iid=iid)
#tmpl_context.widget = self.new_form
#return dict(value=kw, model=self.model.__name__)
@catch_errors(errors, error_handler=new)
@expose()
@registered_validate(error_handler=new)
def post(self, *args, **kw):
userfile = kw['userfile']
log.debug("kwwww: %s" % kw)
forbidden_files = [".js", ".htm", ".html"]
for forbidden_file in forbidden_files:
if userfile.filename.find(forbidden_file) != -1:
return redirect("/adjuntos/new")
filecontent = userfile.file.read()
new_file = Adjuntos(filename=userfile.filename,
filecontent=filecontent)
DBSession.add(new_file)
DBSession.flush()
redirect("/adjuntos/new")
#self.provider.create(self.model, params=kw)
raise redirect('/adjuntos/new')
@expose()
@registered_validate(error_handler=edit)
@catch_errors(errors, error_handler=edit)
def put(self, *args, **kw):
"""update"""
pks = self.provider.get_primary_fields(self.model)
for i, pk in enumerate(pks):
if pk not in kw and i < len(args):
kw[pk] = args[i]
self.provider.update(self.model, params=kw)
redirect('../' * len(pks))
@expose()
def post_delete(self, *args, **kw):
"""
pks = self.provider.get_primary_fields(self.model)
d = {}
for i, arg in enumerate(args):
d[pks[i]] = arg
self.provider.delete(self.model, d)
redirect('./' + '../' * (len(pks) - 1))
"""
log.debug("Estoy en el PostDelete")
"""
def delete(self, fileid):
try:
userfile = DBSession.query(Adjuntos).filter_by(id=fileid).one()
except:
return redirect("/adjuntos/new")
DBSession.delete(userfile)
return redirect("/adjuntos/new")
"""
return redirect("/adjuntos/new")
@expose('tgext.crud.templates.get_delete')
def get_delete(self, *args, **kw):
"""This is the code that creates a confirm_delete page"""
return dict(args=args)
class CrudRestController(RestController):
"""
:variables:
session
database session (drives drop-down menus
menu_items
Dictionary of links to other models in the form model_items[lower_model_name] = Model
title
Title to be used for each page. default: Turbogears Admin System
:modifiers:
model
Model this class is associated with
table
Widget for the table display
table_filler
Class instance with get_value() that defines the JSon stream for the table
edit_form
Form to be used for editing the model
edit_filler
Class instance with a get_value() that defines how we get information for a single
existing record
new_form
Form that defines how we create a form for new data entry.
:Attributes:
menu_items
Dictionary of associated Models (used for menu)
provider
sprox provider for data manipulation
session
link to the database
"""
title = "Turbogears Admin System"
def _before(self, *args, **kw):
tmpl_context.title = self.title
tmpl_context.menu_items = self.menu_items
def __before__(self, *args, **kw):
# this will be removed in 2.1.*
tmpl_context.menu_items = self.menu_items
tmpl_context.title = self.title
def __init__(self, session, menu_items=None):
if menu_items is None:
menu_items = {}
self.menu_items = menu_items
self.provider = ProviderTypeSelector().get_selector(self.model).get_provider(self.model, hint=session)
self.session = session
#this makes crc declarative
check_types = ['new_form', 'edit_form', 'table', 'table_filler', 'edit_filler']
for type_ in check_types:
if not hasattr(self, type_) and hasattr(self, type_+'_type'):
setattr(self, type_, getattr(self, type_+'_type')(self.session))
if hasattr(self, 'new_form'):
#register the validators since they are none from the parent class
register_validators(self, 'post', self.new_form)
if hasattr(self, 'edit_form'):
register_validators(self, 'put', self.edit_form)
@with_trailing_slash
@expose('tgext.crud.templates.get_all')
@expose('json')
@paginate('value_list', items_per_page=7)
def get_all(self, *args, **kw):
"""Return all records.
Pagination is done by offset/limit in the filler method.
Returns an HTML page with the records if not json.
"""
if pylons.request.response_type == 'application/json':
return self.table_filler.get_value(**kw)
if not getattr(self.table.__class__, '__retrieves_own_value__', False):
values = self.table_filler.get_value(**kw)
else:
values = []
tmpl_context.widget = self.table
return dict(model=self.model.__name__, value_list=values)
@expose('tgext.crud.templates.get_one')
@expose('json')
def get_one(self, *args, **kw):
"""get one record, returns HTML or json"""
#this would probably only be realized as a json stream
tmpl_context.widget = self.edit_form
pks = self.provider.get_primary_fields(self.model)
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
return dict(value=value,model=self.model.__name__)
@expose('tgext.crud.templates.edit')
def edit(self, *args, **kw):
"""Display a page to edit the record."""
tmpl_context.widget = self.edit_form
#pks = self.provider.get_primary_fields(self.model)
###########################################
pks = self.provider.get_primary_fields(self.model)
###########################################
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
value['_method'] = 'PUT'
return dict(value=value, model=self.model.__name__, pk_count=len(pks))
@without_trailing_slash
#@expose('tgext.crud.templates.new')
@expose("sap.templates.desarrollar.itemlineabase.new")
def new(self,lid=None ,*args, **kw):
tmpl_context.widget = self.new_form
if len(kw)<2:
"""-----obtiene el idFase de la en el que esta la linea base------- """
fid=DBSession.query(LineaBase.idFase).filter_by(id=lid).first()
log.debug("fidddd= %s" %fid)
"""-----------------------------------------------------------------"""
emfaseactual= [x for x in DBSession.query(Item.id, Item.nombre).filter_by(idFase=fid,idLineaBase=None).all()]
return dict(value={'lineabase':lid}, model=self.model.__name__,items_options=itemfaseactual)
"""Este else es como el Post.Como,al guardar no se va al Post,vuelve al new, entonces se le creo este "else" """
else:
kw2=dict()
kw2['id']=kw['items']
kw2['idLineaBase']=kw['lineabase']
self.provider.update(self.model, params=kw2)
raise redirect('../' +'../itemlineabase/?lid='+ kw['lineabase'])
@catch_errors(errors, error_handler=new)
@expose()
@registered_validate(error_handler=new)
def post(self, *args, **kw):
""" este Post, no es llamado en ningun momento, razon por la cual es reemplazado por el "else" que esta en New"""
log.debug("postItemLinea: %s" %kw)
#self.provider.create(self.model, params=kw)
raise redirect('../' +'../itemlineabase/?fid=21')
@expose()
@registered_validate(error_handler=edit)
@catch_errors(errors, error_handler=edit)
def put(self, *args, **kw):
"""update"""
pks = self.provider.get_primary_fields(self.model)
for i, pk in enumerate(pks):
if pk not in kw and i < len(args):
kw[pk] = args[i]
self.provider.update(self.model, params=kw)
redirect('../' * len(pks))
@expose()
def post_delete(self, *args, **kw):
"""This is the code that actually deletes the record"""
pks = self.provider.get_primary_fields(self.model)
d = {}
for i, arg in enumerate(args):
d[pks[i]] = arg
self.provider.delete(self.model, d)
redirect('./' + '../' * (len(pks) - 1))
@expose('tgext.crud.templates.get_delete')
def get_delete(self, *args, **kw):
"""This is the code that creates a confirm_delete page"""
return dict(args=args)
class CrudRestController(RestController):
"""
:variables:
session
database session (drives drop-down menus
menu_items
Dictionary of links to other models in the form model_items[lower_model_name] = Model
title
Title to be used for each page. default: Turbogears Admin System
:modifiers:
model
Model this class is associated with
table
Widget for the table display
table_filler
Class instance with get_value() that defines the JSon stream for the table
edit_form
Form to be used for editing the model
edit_filler
Class instance with a get_value() that defines how we get information for a single
existing record
new_form
Form that defines how we create a form for new data entry.
:Attributes:
menu_items
Dictionary of associated Models (used for menu)
provider
sprox provider for data manipulation
session
link to the database
"""
title = "Turbogears Admin System"
def _before(self, *args, **kw):
tmpl_context.title = self.title
tmpl_context.menu_items = self.menu_items
def __before__(self, *args, **kw):
# this will be removed in 2.1.*
tmpl_context.menu_items = self.menu_items
tmpl_context.title = self.title
def __init__(self, session, menu_items=None):
if menu_items is None:
menu_items = {}
self.menu_items = menu_items
self.provider = ProviderTypeSelector().get_selector(self.model).get_provider(self.model, hint=session)
self.session = session
#this makes crc declarative
check_types = ['new_form', 'edit_form', 'table', 'table_filler', 'edit_filler']
for type_ in check_types:
if not hasattr(self, type_) and hasattr(self, type_+'_type'):
setattr(self, type_, getattr(self, type_+'_type')(self.session))
if hasattr(self, 'new_form'):
#register the validators since they are none from the parent class
register_validators(self, 'post', self.new_form)
if hasattr(self, 'edit_form'):
register_validators(self, 'put', self.edit_form)
@with_trailing_slash
@expose('tgext.crud.templates.get_all')
@expose('json')
@paginate('value_list', items_per_page=7)
def get_all(self, *args, **kw):
"""Return all records.
Pagination is done by offset/limit in the filler method.
Returns an HTML page with the records if not json.
"""
if pylons.request.response_type == 'application/json':
return self.table_filler.get_value(**kw)
if not getattr(self.table.__class__, '__retrieves_own_value__', False):
values = self.table_filler.get_value(**kw)
else:
values = []
longitud=len(values)
for fila in range(longitud):
complejidad = int(values[fila]['complejidad'])
values[fila]['idFase'] = DBSession.query(Fase.nombre).filter_by(id = values[fila]['idFase']).first()
lineabase = values[fila]['idLineaBase']
if lineabase != 'None':
values[fila]['idLineaBase'] = DBSession.query(LineaBase.nombre)\
.filter_by(id=lineabase).first()
else:
values[fila]['idLineaBase'] = 'Sin linea base'
if (complejidad == 1):
values[fila]['complejidad'] = 'Muy baja (1)'
elif (complejidad == 2):
values[fila]['complejidad'] = 'Baja (2)'
elif (complejidad == 3):
values[fila]['complejidad'] = 'Media (3)'
elif (complejidad == 4):
values[fila]['complejidad'] = 'Alta (4)'
else:
values[fila]['complejidad'] = 'Muy alta (5)'
tmpl_context.widget = self.table
return dict(model=self.model.__name__, value_list=values)
@expose('tgext.crud.templates.get_one')
@expose('json')
def get_one(self, *args, **kw):
"""get one record, returns HTML or json"""
#this would probably only be realized as a json stream
tmpl_context.widget = self.edit_form
pks = self.provider.get_primary_fields(self.model)
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
return dict(value=value,model=self.model.__name__)
@expose('tgext.crud.templates.edit')
def edit(self, *args, **kw):
"""este codigo es ejecutado cuando se revierte un item """
pks = self.provider.get_primary_fields(self.model)
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
"""-----------Se obtiene el item a revertir -------------"""
item=DBSession.query(Item).filter_by(id=kw['id']).first()
"""------------------------------------------------------"""
"""------obtine el numero de la mayor version del item---"""
versionmayor= DBSession.query(Item.version).filter_by(nrohistorial=item.nrohistorial ,ultimaversion=1).first()
"""------------------------------------------------------"""
""" ---el item con la version mayor, cambia su ultimaversion a cero --- """
item3=DBSession.query(Item).filter_by(nrohistorial=item.nrohistorial,ultimaversion=1).first()
log.debug('item3= %s'%item3 )
item3.ultimaversion=0
log.debug("versionmayor= %s" %versionmayor[0])
item2=Item()
item2.nombre=item.nombre
item2.idTipoDeItem=item.idTipoDeItem
item2.idFase=item.idFase
item2.idLineaBase=item.idLineaBase
"""el item a revertir aumenta su version a la ultima y el
el item con la ultima version, "ultima version" pasa a 0 """
item2.version= versionmayor[0]+1
item2.ultimaversion=1
item2.estado=item.estado
item2.complejidad=item.complejidad
item2.fechaCreacion=item.fechaCreacion
item2.nrohistorial=item.nrohistorial
DBSession.add(item2)
"""Realiza copia de los valores de los atributos especificos"""
atributoeditado=DBSession.query(DetalleItem).filter_by(iditem=item.id).all()
for objeto in atributoeditado:
nuevoDetalle=DetalleItem()
nuevoDetalle.tipo=objeto.tipo
nuevoDetalle.nombrecampo=objeto.nombrecampo
nuevoDetalle.valor=objeto.valor
nuevoDetalle.iditem=item2.id #el ID del nuevo item
DBSession.add(nuevoDetalle)
"""Realiza copia de los adjuntos"""
adjuntositemeditado=DBSession.query(Adjuntos).filter_by(idItem=item.id).all()
for adj in adjuntositemeditado:
log.debug("adj: %s" %adj)
itemnuevoadjunto=Adjuntos()
itemnuevoadjunto.idItem=item2.id
itemnuevoadjunto.filename=adj.filename
itemnuevoadjunto.filecontent=adj.filecontent
DBSession.add(itemnuevoadjunto)
"""Copia las relaciones """
relaciones = DBSession.query(RelacionItem.idItem1,RelacionItem.idItem2).filter((RelacionItem.idItem2==item.id) | (RelacionItem.idItem1==item.id)).all()
longitud = len(relaciones)
for x in range(longitud):
newRelation=RelacionItem()
if int(item.id) == int(relaciones[x][0]):
newRelation.idItem1=int(item2.id)
newRelation.idItem2=relaciones[x][1]
DBSession.add(newRelation)
#self.provider.create(RelacionItem, params=newRelation)
elif int(item.id) == int(relaciones[x][1]):
newRelation.idItem1=relaciones[x][0]
newRelation.idItem2=int(item2.id)
DBSession.add(newRelation)
redirect('../'+'../item/?fid=' + str(item.idFase))
@without_trailing_slash
@expose('tgext.crud.templates.new')
def new(self, *args, **kw):
"""Display a page to show a new record."""
tmpl_context.widget = self.new_form
return dict(value=kw, model=self.model.__name__)
@catch_errors(errors, error_handler=new)
@expose()
@registered_validate(error_handler=new)
def post(self, *args, **kw):
self.provider.create(self.model, params=kw)
#########
#if len(kw['idproyec']) > 0:
# raise redirect('./?pid='+kw['idproyec'])
#else:
# if len(kw['idFase']) > 0:
# raise redirect('./?fid='+kw['idFase'])
# else:
# raise redirect('./')
#########
raise redirect('./')
@expose()
@registered_validate(error_handler=edit)
@catch_errors(errors, error_handler=edit)
def put(self, *args, **kw):
"""update"""
pks = self.provider.get_primary_fields(self.model)
for i, pk in enumerate(pks):
if pk not in kw and i < len(args):
kw[pk] = args[i]
self.provider.update(self.model, params=kw)
redirect('../' * len(pks))
@expose()
def post_delete(self, *args, **kw):
"""This is the code that actually deletes the record"""
pks = self.provider.get_primary_fields(self.model)
d = {}
for i, arg in enumerate(args):
d[pks[i]] = arg
self.provider.delete(self.model, d)
redirect('./' + '../' * (len(pks) - 1))
@expose('tgext.crud.templates.get_delete')
def get_delete(self, *args, **kw):
"""This is the code that creates a confirm_delete page"""
return dict(args=args)
class ApiCrudRestController(BaseController, RestController):
allow_only = predicates.not_anonymous()
omit_fields = ['user', '_user_id']
model = None
def __init__(self):
super().__init__()
self.provider = ProviderTypeSelector().get_selector(self.model).get_provider(self.model, hint=db)
# if not hasattr(self, 'new_form'):
# class EditForm(EditableForm):
# __entity__ = self.model
# __omit_fields__ = self.omit_fields
#
# self.edit_form = EditForm(session)
#
# register_validators(self, 'post', self.new_form)
#
# if not hasattr(self, 'edit_form'):
# class NewForm(AddRecordForm):
# __entity__ = self.model
# __omit_fields__ = self.omit_fields
#
# self.new_form = NewForm(session)
#
# register_validators(self, 'put', self.edit_form)
def _dictify(self, value):
if self.omit_fields is False:
return value
def _dictify(entity):
if hasattr(entity, '__json__'):
return entity.__json__()
else:
return self.provider.dictify(entity, omit_fields=self.omit_fields)
if isinstance(value, list):
# return a generator, we don't want to consume the whole query
return (_dictify(entity) for entity in value)
else:
return _dictify(value)
def _before(self, *args, **kw):
pass
# if request.response_type != 'application/json':
# abort(406, 'Only JSON requests are supported')
def _prepare_query(self):
return db.query(self.model).with_parent(request.identity["user"])
def _filter_query(self, query, limit=0, offset=0, order_by="", pagesize=10, page=0, filter="", **kw):
if limit:
query = query.limit(limit)
if limit and offset:
query = query.offset(offset)
if order_by:
for col in [col.split("|") for col in order_by.split(";")]:
field_name = col[0]
if not hasattr(self.model, field_name):
continue
field = getattr(self.model, field_name)
if len(col) == 2:
strategy = col[1].lower()
if strategy == "asc":
field = field.asc()
if strategy == "desc":
field = field.desc()
query = query.order_by(field)
# TODO: pagesize=10&page=1
# TODO: filter={ field: { $gt: value1, $lt: value2 } }
return query
@expose('json')
def get_all(self, **kw):
"""
model?limit=5
model?limit=5&offset=2
model?order_by=amount
model?order_by=date|desc;amount|desc
model?pagesize=10&page=1
:param kw:
:return:
"""
query = self._prepare_query(**kw)
filtered_query = self._filter_query(query, **kw)
entities = filtered_query.all()
if entities is None:
abort(404, 'Not found')
return {'value_list': self._dictify(entities), 'total_entries': query.count(), 'entries': filtered_query.count()}
@expose('json')
def get_one(self, id, **kw):
entity = self._prepare_query(**kw).filter(self.model.id == id).first()
if entity is None:
abort(404, 'Not found')
return {'value': self._dictify(entity)}
@expose('json')
# @registered_validate()
def post(self, **kw):
# if request.response_type != 'application/json':
# abort(406, 'Only JSON requests are supported')
if request.validation['errors']:
return "There was an error"
entity = self.model(**request.json_body)
entity._user_id = request.identity["user"].id
db.add(entity)
db.flush()
return self.get_one(entity.id, **kw)
@expose('json')
# @registered_validate()
def put(self, id, **kw):
# if request.response_type != 'application/json':
# abort(406, 'Only JSON requests are supported')
entity = self._prepare_query(**kw).filter(self.model.id == id).first()
if not entity:
response.status_code = 404
return {'error': 'no exists'}
for key, value in request.json_body.items():
setattr(entity, key, value)
db.flush()
return self.get_one(id, **kw)
@expose('json')
def post_delete(self, id, **kw):
self._prepare_query(**kw).filter(self.model.id == id).delete()
def __init__(self):
super().__init__()
self.provider = ProviderTypeSelector().get_selector(self.model).get_provider(self.model, hint=db)
__entity__ = self.model
self.new_filler_type = NewFiller
def __init__(self, model, translations=None, **kw):
super(CrudRestControllerConfig, self).__init__()
self.model = model
self._do_init_with_translations(translations)
self._post_init()
def _do_init_with_translations(self, translations):
pass
provider_type_selector = ProviderTypeSelector()
class AdminConfig(object):
"""
:class attributes:
**layout**
The look and feel of the admin.
Three builtin layouts are available: ``tgext.admin.layouts.BasicAdminLayout``,
``tgext.admin.layouts.BootstrapAdminLayout`` and
``tgext.admin.layouts.GroupedBootstrapAdminLayout``.
.. note::
``GroupedBootstrapAdminLayout`` only works with the Genshi and Kajiki
template languages, so it cannot be used when quickstarting with Jinja or Mako.
class CrudRestController(RestController):
"""
:variables:
session
database session (drives drop-down menus
menu_items
Dictionary of links to other models in the form model_items[lower_model_name] = Model
title
Title to be used for each page. default: Turbogears Admin System
:modifiers:
model
Model this class is associated with
table
Widget for the table display
table_filler
Class instance with get_value() that defines the JSon stream for the table
edit_form
Form to be used for editing the model
edit_filler
Class instance with a get_value() that defines how we get information for a single
existing record
new_form
Form that defines how we create a form for new data entry.
:Attributes:
menu_items
Dictionary of associated Models (used for menu)
provider
sprox provider for data manipulation
session
link to the database
"""
title = "Turbogears Admin System"
keep_params = None
remember_values = []
style = literal('''
#menu_items {
padding:0px 12px 0px 2px;
list-style-type:None;
padding-left:0px;
}
#crud_leftbar {
float:left;
padding-left:0px;
}
#crud_content {
float:left;
width:80%;
}
#crud_content > h1,
.crud_edit > h2,
.crud_add > h2 {
margin-top: 1px;
}
#crud_btn_new {
margin:1ex 0;
}
#crud_btn_new > span {
margin-left:2em;
}
#crud_search {
float: right;
}
#crud_search input {
border: 1px solid #CCC;
background-color: white;
}
#crud_search input:hover {
background-color: #EFEFEF;
}
''')
def _before(self, *args, **kw):
tmpl_context.title = self.title
tmpl_context.menu_items = self.menu_items
tmpl_context.kept_params = self._kept_params()
tmpl_context.crud_helpers = self.helpers
tmpl_context.crud_style = self.style
def __before__(self, *args, **kw):
# this will be removed in 2.2.*
tmpl_context.menu_items = self.menu_items
tmpl_context.title = self.title
tmpl_context.kept_params = self._kept_params()
tmpl_context.crud_helpers = self.helpers
tmpl_context.crud_style = self.style
def _mount_point(self):
try:
mount_point = self.mount_point
except:
mount_point = None
if not mount_point:
#non statically mounted or Old TurboGears, use relative URL
mount_point = '.'
return mount_point
def _kept_params(self):
if not self.keep_params:
return {}
if not request.referer:
from_referer = {}
else:
parsed = urlparse.urlparse(request.referer)
from_referer = dict(cgi.parse_qsl(parsed.query))
from_referer.update(request.params)
pass_params = {}
for k in self.keep_params:
if k in from_referer:
pass_params[k] = from_referer[k]
return pass_params
def _adapt_menu_items(self, menu_items):
adapted_menu_items = {}
for link, model in menu_items.iteritems():
if inspect.isclass(model):
adapted_menu_items[link + 's'] = model.__name__
else:
adapted_menu_items[link] = model
return adapted_menu_items
def __init__(self, session, menu_items=None):
if menu_items is None:
menu_items = {}
self.menu_items = self._adapt_menu_items(menu_items)
self.helpers = CrudRestControllerHelpers()
self.provider = ProviderTypeSelector().get_selector(self.model).get_provider(self.model, hint=session)
self.session = session
#this makes crc declarative
check_types = ['new_form', 'edit_form', 'table', 'table_filler', 'edit_filler']
for type_ in check_types:
if not hasattr(self, type_) and hasattr(self, type_+'_type'):
setattr(self, type_, getattr(self, type_+'_type')(self.session))
if hasattr(self, 'new_form'):
#register the validators since they are none from the parent class
register_validators(self, 'post', self.new_form)
if hasattr(self, 'edit_form'):
register_validators(self, 'put', self.edit_form)
@with_trailing_slash
@expose('genshi:tgext.crud.templates.get_all')
@expose('mako:tgext.crud.templates.get_all')
@expose('jinja:tgext.crud.templates.get_all')
@expose('json')
@paginate('value_list', items_per_page=7)
def get_all(self, *args, **kw):
"""Return all records.
Pagination is done by offset/limit in the filler method.
Returns an HTML page with the records if not json.
"""
if tg.request.response_type == 'application/json':
return self.table_filler.get_value(**kw)
if not getattr(self.table.__class__, '__retrieves_own_value__', False):
kw.pop('limit', None)
kw.pop('offset', None)
if isinstance(self.table_filler, RequestLocalTableFiller):
paginator = request.paginators['value_list']
page = paginator.paginate_page - 1
values = self.table_filler.get_value(offset=page*paginator.paginate_items_per_page,
limit=paginator.paginate_items_per_page,
**kw)
values = SmartPaginationCollection(values, self.table_filler.__count__)
else:
values = self.table_filler.get_value(**kw)
else:
values = []
tmpl_context.widget = self.table
headers = get_table_headers(self.table)
return dict(model=self.model.__name__, value_list=values,
mount_point=self._mount_point(),
headers=headers)
@expose('genshi:tgext.crud.templates.get_one')
@expose('mako:tgext.crud.templates.get_one')
@expose('jinja:tgext.crud.templates.get_one')
@expose('json')
def get_one(self, *args, **kw):
"""get one record, returns HTML or json"""
#this would probably only be realized as a json stream
tmpl_context.widget = self.edit_form
pks = self.provider.get_primary_fields(self.model)
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
return dict(value=value,model=self.model.__name__)
@expose('genshi:tgext.crud.templates.edit')
@expose('mako:tgext.crud.templates.edit')
@expose('jinja:tgext.crud.templates.edit')
def edit(self, *args, **kw):
"""Display a page to edit the record."""
tmpl_context.widget = self.edit_form
pks = self.provider.get_primary_fields(self.model)
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
value['_method'] = 'PUT'
return dict(value=value, model=self.model.__name__, pk_count=len(pks))
@without_trailing_slash
@expose('genshi:tgext.crud.templates.new')
@expose('mako:tgext.crud.templates.new')
@expose('jinja:tgext.crud.templates.new')
def new(self, *args, **kw):
"""Display a page to show a new record."""
tmpl_context.widget = self.new_form
return dict(value=kw, model=self.model.__name__)
@catch_errors(errors, error_handler=new)
@expose()
@registered_validate(error_handler=new)
def post(self, *args, **kw):
self.provider.create(self.model, params=kw)
raise redirect('./', params=self._kept_params())
@expose()
@registered_validate(error_handler=edit)
@catch_errors(errors, error_handler=edit)
def put(self, *args, **kw):
"""update"""
pks = self.provider.get_primary_fields(self.model)
for i, pk in enumerate(pks):
if pk not in kw and i < len(args):
kw[pk] = args[i]
omit_fields = []
if getattr(self, 'edit_form', None):
omit_fields.extend(self.edit_form.__omit_fields__)
for remembered_value in self.remember_values:
value = kw.get(remembered_value)
if value is None or value == '':
omit_fields.append(remembered_value)
self.provider.update(self.model, params=kw, omit_fields=omit_fields)
redirect('../' * len(pks), params=self._kept_params())
@expose()
def post_delete(self, *args, **kw):
"""This is the code that actually deletes the record"""
pks = self.provider.get_primary_fields(self.model)
d = {}
for i, arg in enumerate(args):
d[pks[i]] = arg
self.provider.delete(self.model, d)
redirect('./' + '../' * (len(pks) - 1), params=self._kept_params())
@expose('genshi:tgext.crud.templates.get_delete')
@expose('jinja:tgext.crud.templates.get_delete')
def get_delete(self, *args, **kw):
"""This is the code that creates a confirm_delete page"""
return dict(args=args)
class CrudRestController(RestController):
"""
:variables:
session
database session (drives drop-down menus
menu_items
Dictionary of links to other models in the form model_items[lower_model_name] = Model
title
Title to be used for each page. default: Turbogears Admin System
:modifiers:
model
Model this class is associated with
table
Widget for the table display
table_filler
Class instance with get_value() that defines the JSon stream for the table
edit_form
Form to be used for editing the model
edit_filler
Class instance with a get_value() that defines how we get information for a single
existing record
new_form
Form that defines how we create a form for new data entry.
:Attributes:
menu_items
Dictionary of associated Models (used for menu)
provider
sprox provider for data manipulation
session
link to the database
"""
title = "Turbogears Admin System"
def _before(self, *args, **kw):
tmpl_context.title = self.title
tmpl_context.menu_items = self.menu_items
def __before__(self, *args, **kw):
# this will be removed in 2.1.*
tmpl_context.menu_items = self.menu_items
tmpl_context.title = self.title
def __init__(self, session, menu_items=None):
if menu_items is None:
menu_items = {}
self.menu_items = menu_items
self.provider = ProviderTypeSelector().get_selector(self.model).get_provider(self.model, hint=session)
self.session = session
#this makes crc declarative
check_types = ['new_form', 'edit_form', 'table', 'table_filler', 'edit_filler']
for type_ in check_types:
if not hasattr(self, type_) and hasattr(self, type_+'_type'):
setattr(self, type_, getattr(self, type_+'_type')(self.session))
if hasattr(self, 'new_form'):
#register the validators since they are none from the parent class
register_validators(self, 'post', self.new_form)
if hasattr(self, 'edit_form'):
register_validators(self, 'put', self.edit_form)
@with_trailing_slash
@expose('tgext.crud.templates.get_all')
@expose('json')
@paginate('value_list', items_per_page=7)
def get_all(self, *args, **kw):
"""Return all records.
Pagination is done by offset/limit in the filler method.
Returns an HTML page with the records if not json.
"""
if pylons.request.response_type == 'application/json':
return self.table_filler.get_value(**kw)
if not getattr(self.table.__class__, '__retrieves_own_value__', False):
values = self.table_filler.get_value(**kw)
else:
values = []
longitud=len(values)
for fila in range(longitud):
complejidad = int(values[fila]['complejidad'])
values[fila]['idFase'] = DBSession.query(Fase.nombre).filter_by(id = values[fila]['idFase']).first()
lineabase = values[fila]['idLineaBase']
if lineabase != 'None':
values[fila]['idLineaBase'] = DBSession.query(LineaBase.nombre)\
.filter_by(id=lineabase).first()
else:
values[fila]['idLineaBase'] = 'Sin linea base'
if (complejidad == 1):
values[fila]['complejidad'] = 'Muy baja (1)'
elif (complejidad == 2):
values[fila]['complejidad'] = 'Baja (2)'
elif (complejidad == 3):
values[fila]['complejidad'] = 'Media (3)'
elif (complejidad == 4):
values[fila]['complejidad'] = 'Alta (4)'
else:
values[fila]['complejidad'] = 'Muy alta (5)'
tmpl_context.widget = self.table
return dict(model=self.model.__name__, value_list=values)
@expose('tgext.crud.templates.get_one')
@expose('json')
def get_one(self, *args, **kw):
"""get one record, returns HTML or json"""
#this would probably only be realized as a json stream
tmpl_context.widget = self.edit_form
pks = self.provider.get_primary_fields(self.model)
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
return dict(value=value,model=self.model.__name__)
@expose('sap.templates.desarrollar.item.edit')
#@expose("sap.templates.desarrollar.item.get_all")
def edit(self, *args, **kw):
"""Display a page to edit the record."""
tmpl_context.widget = self.edit_form
pks = self.provider.get_primary_fields(self.model)
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
value['_method'] = 'PUT'
return dict(value=value, model=self.model.__name__, pk_count=len(pks))
@without_trailing_slash
#@expose('tgext.crud.templates.new')
@expose('sap.templates.desarrollar.item.new')
def new(self,tid=None ,*args, **kw):
"""Display a page to show a new record."""
fid= DBSession.query(TipoDeItem.idFase).filter_by(id=tid).first()
"""Extra los campos del tipo de Item elegido """
"""fields=[]
campotipo= DBSession.query(Campos.tipoDeDato, Campos.nombre).filter_by(idTipoDeItem=13).all()
for ct in campotipo:
#log.debug(ct[1])
campo1 = TextField(ct[1], label_text= ct[1])
fields.append(campo1)
item_add_form = ItemForm('create_item_form', fields)
tmpl_context.widget = item_add_form
"""
tmpl_context.widget = self.new_form
#return dict(value=kw, model=self.model.__name__)
#child_args=dict(child_args=form_fields_dict)
return dict(value={'idTipoDeItem':tid, 'idFase':fid, },model=self.model.__name__)
@catch_errors(errors, error_handler=new)
@expose()
@registered_validate(error_handler=new)
def post(self, *args, **kw):
"""extrae el numhistorial ordenado sin repetir, para luego tomar el mayor valor y asi
poder asignarle un numhistorial mayor
"""
num=[x for x in (DBSession.query(Item.nrohistorial).order_by(Item.nrohistorial.desc()).distinct())]
"""Por cada Item creado, aumenta el nrohistorial en una unidad """
if num != None and len(num)>0:
kw['nrohistorial']=int(num[0][0]) + 1
else:
kw['nrohistorial']=1
fase = DBSession.query(Fase).filter_by(id=kw['idFase']).first()
if str(fase.estado).__eq__('inicial'):
fase.estado = 'desarrollo'
elif str(fase.estado).__eq__('lineaBaseTotal'):
fase.estado = 'lineaBaseParcial'
#self.provider.create(self.model, params=kw)
raise redirect('./?fid='+kw['idFase'])
@expose()
@registered_validate(error_handler=edit)
@catch_errors(errors, error_handler=edit)
def put(self, *args, **kw):
"""update"""
pks = self.provider.get_primary_fields(self.model)
for i, pk in enumerate(pks):
if pk not in kw and i < len(args):
kw[pk] = args[i]
"""Extrae todos los valores del item a modificar, para luego crear un nuevo item"""
valoresItem=DBSession.query(Item.version ,Item.idTipoDeItem ,Item.idFase ,Item.idLineaBase ,Item.fechaCreacion ,Item.nrohistorial,Item.ultimaversion).filter_by(id=kw['id']).first()
"""Se crea una lista, y se le agrega los valores que tendra el item. """
nuevo={}
nuevo['version']=valoresItem[0]+1
nuevo['idTipoDeItem']=valoresItem[1]
nuevo['idFase']=valoresItem[2]
nuevo['idLineaBase']=valoresItem[3]
nuevo['fechaCreacion']=str(valoresItem[4])
nuevo['nrohistorial']=valoresItem[5]
nuevo['ultimaversion']=valoresItem[6]
nuevo['estado']='modificado'
nuevo['complejidad']=kw['complejidad']
nuevo['nombre']=kw['nombre']
itemnuevo=self.provider.create(self.model, params=nuevo)
"""Realiza copia de los valores de los atributos especificos"""
itemeditado=DBSession.query(Item).filter_by(id=kw['id']).first()
atributoeditado=DBSession.query(DetalleItem).filter_by(iditem=itemeditado.id).all()
for objeto in atributoeditado:
nuevoDetalle=DetalleItem()
nuevoDetalle.tipo=objeto.tipo
nuevoDetalle.nombrecampo=objeto.nombrecampo
nuevoDetalle.valor=objeto.valor
nuevoDetalle.iditem=itemnuevo.id
DBSession.add(nuevoDetalle)
"""Realiza copia de los adjuntos"""
adjuntositemeditado=DBSession.query(Adjuntos).filter_by(idItem=itemeditado.id).all()
for adj in adjuntositemeditado:
itemnuevoadjunto=Adjuntos()
itemnuevoadjunto.idItem=itemnuevo.id
itemnuevoadjunto.filename=adj.filename
itemnuevoadjunto.filecontent=adj.filecontent
DBSession.add(itemnuevoadjunto)
"""-----------------------------"""
itemeditado=DBSession.query(Item).filter_by(id=kw['id']).first()
itemeditado.ultimaversion=0
itemnuevo=DBSession.query(Item.id).filter_by(nrohistorial=nuevo['nrohistorial'], ultimaversion=1).first()
relaciones = DBSession.query(RelacionItem.idItem1,RelacionItem.idItem2).filter((RelacionItem.idItem2==itemeditado.id) | (RelacionItem.idItem1==itemeditado.id)).all()
longitud = len(relaciones)
newRelation = {}
for x in range(longitud):
if int(itemeditado.id) == int(relaciones[x][0]):
newRelation['idItem1']=int(itemnuevo[0])
newRelation['idItem2']=relaciones[x][1]
self.provider.create(RelacionItem, params=newRelation)
elif int(itemeditado.id) == int(relaciones[x][1]):
newRelation['idItem1']=relaciones[x][0]
newRelation['idItem2']=int(itemnuevo[0])
self.provider.create(RelacionItem, params=newRelation)
ids=[]
ids.append(int(itemnuevo[0]))
self.recorrerArbolAtras(ids, int(itemnuevo[0]))
self.recorrerArbolAdelante(ids, int(itemnuevo[0]))
ids.remove(int(itemnuevo[0]))
longitudids = len(ids)
for x in range(longitudids):
itemrevision = DBSession.query(Item).filter_by(id=ids[x], ultimaversion=1).first()
if itemrevision != None:
if itemrevision.estado != 'modificado':
itemrevision.estado = 'revision'
if itemrevision.idLineaBase != None:
lineabase = DBSession.query(LineaBase).filter_by(id=itemrevision.idLineaBase).first()
if lineabase.estado == 'cerrada':
lineabase.estado = 'comprometida'
listalineabase = DBSession.query(LineaBase).filter_by(idFase = lineabase.idFase).all()
desarrollo = True
longitud = len(listalineabase)
for y in range (longitud):
if str(listalineabase[y].estado).__eq__('cerrada'):
desarrollo = False
if desarrollo:
fase = DBSession.query(Fase).filter_by(id = lineabase.idFase).first()
fase.estado = 'desarrollo'
flash("El item \"" +kw['nombre'] +"\" ha sido modificado correctamente")
redirect('../' +'../item/?fid=' + str(nuevo['idFase']))
"""---------------------- Recorrer Arbol Atras -------------------------------------
Uso:
self.recorrerArbol (ids, iid)
ids: un vector que contiene primeramente al nodo inicial
iid: nodo inicial
Todos los nodos del arbol quedaran guardados en ids---------------------------"""
def recorrerArbolAtras (self, *args):
ids = args[0]
itemraiz = args[1]
"""-------------Obtiene de la BD las relaciones actuales del nodo en cuestion---"""
relaciones = DBSession.query(RelacionItem.idItem1,RelacionItem.idItem2).\
filter((RelacionItem.idItem1==itemraiz)).all()
"""------------------------------------------------------------------------"""
for relacion in relaciones:
itemrelacion = DBSession.query(Item).filter_by(id=relacion.idItem2).first()
if itemrelacion.ultimaversion == 1:
if (ids.count(itemrelacion.id) < 1):
ids.append(itemrelacion.id)
self.recorrerArbolAtras(ids, itemrelacion.id)
"""------------------- Fin Recorrer Arbol Atras -----------------------------------"""
"""-------------------- Recorrer Arbol Adelante -------------------------------------
Uso:
self.recorrerArbol (ids, iid)
ids: un vector que contiene primeramente al nodo inicial
iid: nodo inicial
Todos los nodos del arbol quedaran guardados en ids---------------------------"""
def recorrerArbolAdelante (self, *args):
ids = args[0]
itemraiz = args[1]
"""-------------Obtiene de la BD las relaciones actuales del nodo en cuestion---"""
relaciones = DBSession.query(RelacionItem.idItem1,RelacionItem.idItem2).\
filter((RelacionItem.idItem2==itemraiz)).all()
"""------------------------------------------------------------------------"""
for relacion in relaciones:
itemrelacion = DBSession.query(Item).filter_by(id=relacion.idItem1).first()
if itemrelacion.ultimaversion == 1:
if (ids.count(itemrelacion.id) < 1):
ids.append(itemrelacion.id)
self.recorrerArbolAdelante(ids, itemrelacion.id)
"""---------------------- Fin Recorrer Arbol Adelante -----------------------------"""
@expose()
def post_delete(self, *args, **kw):
"""This is the code that actually deletes the record"""
pks = self.provider.get_primary_fields(self.model)
d = {}
for i, arg in enumerate(args):
d[pks[i]] = arg
"""extraer el idFase para poder retornar en el estado anterior """
idfase= DBSession.query(Item.idFase).filter_by(id=d['id']).first()
"""------------------------------------------------------------"""
"""Se crea objeto y cambia de estado """
itemeDelete=DBSession.query(Item).filter_by(id=d['id']).first()
itemeDelete.estado="borrado"
itemeDelete.ultimaversion=0
DBSession.add(itemeDelete)
"""---------Se borra las relaciones del Item Borrado--------------"""
relaciones= DBSession.query(RelacionItem).filter((RelacionItem.idItem1==d['id']) | (RelacionItem.idItem2==d['id'])).all()
longitud=len(relaciones)
for x in range(longitud):
DBSession.delete(relaciones[x])
"""---------------------------------------------------------------"""
#self.provider.delete(self.model, d)
#self.provider.delete(self.model, d)
#redirect('./' + '../' * (len(pks) - 1))
raise redirect('/item/?fid='+str(idfase[0]))
@expose('tgext.crud.templates.get_delete')
def get_delete(self, *args, **kw):
"""This is the code that creates a confirm_delete page"""
return dict(args=args)
class CrudRestController(RestController):
"""
:variables:
session
database session (drives drop-down menus
menu_items
Dictionary of links to other models in the form model_items[lower_model_name] = Model
title
Title to be used for each page. default: Turbogears Admin System
:modifiers:
model
Model this class is associated with
table
Widget for the table display
table_filler
Class instance with get_value() that defines the JSon stream for the table
edit_form
Form to be used for editing the model
edit_filler
Class instance with a get_value() that defines how we get information for a single
existing record
new_form
Form that defines how we create a form for new data entry.
:Attributes:
menu_items
Dictionary of associated Models (used for menu)
provider
sprox provider for data manipulation
session
link to the database
"""
title = "Turbogears Admin System"
def _before(self, *args, **kw):
tmpl_context.title = self.title
tmpl_context.menu_items = self.menu_items
def __before__(self, *args, **kw):
# this will be removed in 2.1.*
tmpl_context.menu_items = self.menu_items
tmpl_context.title = self.title
def __init__(self, session, menu_items=None):
if menu_items is None:
menu_items = {}
self.menu_items = menu_items
self.provider = ProviderTypeSelector().get_selector(
self.model).get_provider(self.model, hint=session)
self.session = session
#this makes crc declarative
check_types = [
'new_form', 'edit_form', 'table', 'table_filler', 'edit_filler'
]
for type_ in check_types:
if not hasattr(self, type_) and hasattr(self, type_ + '_type'):
setattr(self, type_,
getattr(self, type_ + '_type')(self.session))
if hasattr(self, 'new_form'):
#register the validators since they are none from the parent class
register_validators(self, 'post', self.new_form)
if hasattr(self, 'edit_form'):
register_validators(self, 'put', self.edit_form)
@with_trailing_slash
@expose('tgext.crud.templates.get_all')
@expose('json')
@paginate('value_list', items_per_page=7)
def get_all(self, *args, **kw):
"""Return all records.
Pagination is done by offset/limit in the filler method.
Returns an HTML page with the records if not json.
"""
if pylons.request.response_type == 'application/json':
return self.table_filler.get_value(**kw)
if not getattr(self.table.__class__, '__retrieves_own_value__', False):
values = self.table_filler.get_value(**kw)
else:
values = []
longitud = len(values)
for fila in range(longitud):
complejidad = int(values[fila]['complejidad'])
values[fila]['idFase'] = DBSession.query(
Fase.nombre).filter_by(id=values[fila]['idFase']).first()
lineabase = values[fila]['idLineaBase']
if lineabase != 'None':
values[fila]['idLineaBase'] = DBSession.query(LineaBase.nombre)\
.filter_by(id=lineabase).first()
else:
values[fila]['idLineaBase'] = 'Sin linea base'
if (complejidad == 1):
values[fila]['complejidad'] = 'Muy baja (1)'
elif (complejidad == 2):
values[fila]['complejidad'] = 'Baja (2)'
elif (complejidad == 3):
values[fila]['complejidad'] = 'Media (3)'
elif (complejidad == 4):
values[fila]['complejidad'] = 'Alta (4)'
else:
values[fila]['complejidad'] = 'Muy alta (5)'
tmpl_context.widget = self.table
return dict(model=self.model.__name__, value_list=values)
@expose('tgext.crud.templates.get_one')
@expose('json')
def get_one(self, *args, **kw):
"""get one record, returns HTML or json"""
#this would probably only be realized as a json stream
tmpl_context.widget = self.edit_form
pks = self.provider.get_primary_fields(self.model)
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
return dict(value=value, model=self.model.__name__)
@expose('sap.templates.desarrollar.item.edit')
#@expose("sap.templates.desarrollar.item.get_all")
def edit(self, *args, **kw):
"""Display a page to edit the record."""
tmpl_context.widget = self.edit_form
pks = self.provider.get_primary_fields(self.model)
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
value['_method'] = 'PUT'
return dict(value=value, model=self.model.__name__, pk_count=len(pks))
@without_trailing_slash
#@expose('tgext.crud.templates.new')
@expose('sap.templates.desarrollar.item.new')
def new(self, tid=None, *args, **kw):
"""Display a page to show a new record."""
fid = DBSession.query(TipoDeItem.idFase).filter_by(id=tid).first()
"""Extra los campos del tipo de Item elegido """
"""fields=[]
campotipo= DBSession.query(Campos.tipoDeDato, Campos.nombre).filter_by(idTipoDeItem=13).all()
for ct in campotipo:
#log.debug(ct[1])
campo1 = TextField(ct[1], label_text= ct[1])
fields.append(campo1)
item_add_form = ItemForm('create_item_form', fields)
tmpl_context.widget = item_add_form
"""
tmpl_context.widget = self.new_form
#return dict(value=kw, model=self.model.__name__)
#child_args=dict(child_args=form_fields_dict)
return dict(value={
'idTipoDeItem': tid,
'idFase': fid,
},
model=self.model.__name__)
@catch_errors(errors, error_handler=new)
@expose()
@registered_validate(error_handler=new)
def post(self, *args, **kw):
"""extrae el numhistorial ordenado sin repetir, para luego tomar el mayor valor y asi
poder asignarle un numhistorial mayor
"""
num = [
x for x in (DBSession.query(Item.nrohistorial).order_by(
Item.nrohistorial.desc()).distinct())
]
"""Por cada Item creado, aumenta el nrohistorial en una unidad """
if num != None and len(num) > 0:
kw['nrohistorial'] = int(num[0][0]) + 1
else:
kw['nrohistorial'] = 1
fase = DBSession.query(Fase).filter_by(id=kw['idFase']).first()
if str(fase.estado).__eq__('inicial'):
fase.estado = 'desarrollo'
elif str(fase.estado).__eq__('lineaBaseTotal'):
fase.estado = 'lineaBaseParcial'
#self.provider.create(self.model, params=kw)
raise redirect('./?fid=' + kw['idFase'])
@expose()
@registered_validate(error_handler=edit)
@catch_errors(errors, error_handler=edit)
def put(self, *args, **kw):
"""update"""
pks = self.provider.get_primary_fields(self.model)
for i, pk in enumerate(pks):
if pk not in kw and i < len(args):
kw[pk] = args[i]
"""Extrae todos los valores del item a modificar, para luego crear un nuevo item"""
valoresItem = DBSession.query(
Item.version, Item.idTipoDeItem, Item.idFase, Item.idLineaBase,
Item.fechaCreacion, Item.nrohistorial,
Item.ultimaversion).filter_by(id=kw['id']).first()
"""Se crea una lista, y se le agrega los valores que tendra el item. """
nuevo = {}
nuevo['version'] = valoresItem[0] + 1
nuevo['idTipoDeItem'] = valoresItem[1]
nuevo['idFase'] = valoresItem[2]
nuevo['idLineaBase'] = valoresItem[3]
nuevo['fechaCreacion'] = str(valoresItem[4])
nuevo['nrohistorial'] = valoresItem[5]
nuevo['ultimaversion'] = valoresItem[6]
nuevo['estado'] = 'modificado'
nuevo['complejidad'] = kw['complejidad']
nuevo['nombre'] = kw['nombre']
itemnuevo = self.provider.create(self.model, params=nuevo)
"""Realiza copia de los valores de los atributos especificos"""
itemeditado = DBSession.query(Item).filter_by(id=kw['id']).first()
atributoeditado = DBSession.query(DetalleItem).filter_by(
iditem=itemeditado.id).all()
for objeto in atributoeditado:
nuevoDetalle = DetalleItem()
nuevoDetalle.tipo = objeto.tipo
nuevoDetalle.nombrecampo = objeto.nombrecampo
nuevoDetalle.valor = objeto.valor
nuevoDetalle.iditem = itemnuevo.id
DBSession.add(nuevoDetalle)
"""Realiza copia de los adjuntos"""
adjuntositemeditado = DBSession.query(Adjuntos).filter_by(
idItem=itemeditado.id).all()
for adj in adjuntositemeditado:
itemnuevoadjunto = Adjuntos()
itemnuevoadjunto.idItem = itemnuevo.id
itemnuevoadjunto.filename = adj.filename
itemnuevoadjunto.filecontent = adj.filecontent
DBSession.add(itemnuevoadjunto)
"""-----------------------------"""
itemeditado = DBSession.query(Item).filter_by(id=kw['id']).first()
itemeditado.ultimaversion = 0
itemnuevo = DBSession.query(Item.id).filter_by(
nrohistorial=nuevo['nrohistorial'], ultimaversion=1).first()
relaciones = DBSession.query(
RelacionItem.idItem1, RelacionItem.idItem2).filter(
(RelacionItem.idItem2 == itemeditado.id)
| (RelacionItem.idItem1 == itemeditado.id)).all()
longitud = len(relaciones)
newRelation = {}
for x in range(longitud):
if int(itemeditado.id) == int(relaciones[x][0]):
newRelation['idItem1'] = int(itemnuevo[0])
newRelation['idItem2'] = relaciones[x][1]
self.provider.create(RelacionItem, params=newRelation)
elif int(itemeditado.id) == int(relaciones[x][1]):
newRelation['idItem1'] = relaciones[x][0]
newRelation['idItem2'] = int(itemnuevo[0])
self.provider.create(RelacionItem, params=newRelation)
ids = []
ids.append(int(itemnuevo[0]))
self.recorrerArbolAtras(ids, int(itemnuevo[0]))
self.recorrerArbolAdelante(ids, int(itemnuevo[0]))
ids.remove(int(itemnuevo[0]))
longitudids = len(ids)
for x in range(longitudids):
itemrevision = DBSession.query(Item).filter_by(
id=ids[x], ultimaversion=1).first()
if itemrevision != None:
if itemrevision.estado != 'modificado':
itemrevision.estado = 'revision'
if itemrevision.idLineaBase != None:
lineabase = DBSession.query(LineaBase).filter_by(
id=itemrevision.idLineaBase).first()
if lineabase.estado == 'cerrada':
lineabase.estado = 'comprometida'
listalineabase = DBSession.query(
LineaBase).filter_by(
idFase=lineabase.idFase).all()
desarrollo = True
longitud = len(listalineabase)
for y in range(longitud):
if str(listalineabase[y].estado).__eq__(
'cerrada'):
desarrollo = False
if desarrollo:
fase = DBSession.query(Fase).filter_by(
id=lineabase.idFase).first()
fase.estado = 'desarrollo'
flash("El item \"" + kw['nombre'] +
"\" ha sido modificado correctamente")
redirect('../' + '../item/?fid=' + str(nuevo['idFase']))
"""---------------------- Recorrer Arbol Atras -------------------------------------
Uso:
self.recorrerArbol (ids, iid)
ids: un vector que contiene primeramente al nodo inicial
iid: nodo inicial
Todos los nodos del arbol quedaran guardados en ids---------------------------"""
def recorrerArbolAtras(self, *args):
ids = args[0]
itemraiz = args[1]
"""-------------Obtiene de la BD las relaciones actuales del nodo en cuestion---"""
relaciones = DBSession.query(RelacionItem.idItem1,RelacionItem.idItem2).\
filter((RelacionItem.idItem1==itemraiz)).all()
"""------------------------------------------------------------------------"""
for relacion in relaciones:
itemrelacion = DBSession.query(Item).filter_by(
id=relacion.idItem2).first()
if itemrelacion.ultimaversion == 1:
if (ids.count(itemrelacion.id) < 1):
ids.append(itemrelacion.id)
self.recorrerArbolAtras(ids, itemrelacion.id)
"""------------------- Fin Recorrer Arbol Atras -----------------------------------"""
"""-------------------- Recorrer Arbol Adelante -------------------------------------
Uso:
self.recorrerArbol (ids, iid)
ids: un vector que contiene primeramente al nodo inicial
iid: nodo inicial
Todos los nodos del arbol quedaran guardados en ids---------------------------"""
def recorrerArbolAdelante(self, *args):
ids = args[0]
itemraiz = args[1]
"""-------------Obtiene de la BD las relaciones actuales del nodo en cuestion---"""
relaciones = DBSession.query(RelacionItem.idItem1,RelacionItem.idItem2).\
filter((RelacionItem.idItem2==itemraiz)).all()
"""------------------------------------------------------------------------"""
for relacion in relaciones:
itemrelacion = DBSession.query(Item).filter_by(
id=relacion.idItem1).first()
if itemrelacion.ultimaversion == 1:
if (ids.count(itemrelacion.id) < 1):
ids.append(itemrelacion.id)
self.recorrerArbolAdelante(ids, itemrelacion.id)
"""---------------------- Fin Recorrer Arbol Adelante -----------------------------"""
@expose()
def post_delete(self, *args, **kw):
"""This is the code that actually deletes the record"""
pks = self.provider.get_primary_fields(self.model)
d = {}
for i, arg in enumerate(args):
d[pks[i]] = arg
"""extraer el idFase para poder retornar en el estado anterior """
idfase = DBSession.query(Item.idFase).filter_by(id=d['id']).first()
"""------------------------------------------------------------"""
"""Se crea objeto y cambia de estado """
itemeDelete = DBSession.query(Item).filter_by(id=d['id']).first()
itemeDelete.estado = "borrado"
itemeDelete.ultimaversion = 0
DBSession.add(itemeDelete)
"""---------Se borra las relaciones del Item Borrado--------------"""
relaciones = DBSession.query(
RelacionItem).filter((RelacionItem.idItem1 == d['id'])
| (RelacionItem.idItem2 == d['id'])).all()
longitud = len(relaciones)
for x in range(longitud):
DBSession.delete(relaciones[x])
"""---------------------------------------------------------------"""
#self.provider.delete(self.model, d)
#self.provider.delete(self.model, d)
#redirect('./' + '../' * (len(pks) - 1))
raise redirect('/item/?fid=' + str(idfase[0]))
@expose('tgext.crud.templates.get_delete')
def get_delete(self, *args, **kw):
"""This is the code that creates a confirm_delete page"""
return dict(args=args)
class CrudRestController(RestController):
"""
:variables:
session
database session (drives drop-down menus
menu_items
Dictionary of links to other models in the form model_items[lower_model_name] = Model
title
Title to be used for each page. default: Turbogears Admin System
:modifiers:
model
Model this class is associated with
table
Widget for the table display
table_filler
Class instance with get_value() that defines the JSon stream for the table
edit_form
Form to be used for editing the model
edit_filler
Class instance with a get_value() that defines how we get information for a single
existing record
new_form
Form that defines how we create a form for new data entry.
:Attributes:
menu_items
Dictionary of associated Models (used for menu)
provider
sprox provider for data manipulation
session
link to the database
"""
title = "Turbogears Admin System"
def _before(self, *args, **kw):
tmpl_context.title = self.title
tmpl_context.menu_items = self.menu_items
def __before__(self, *args, **kw):
# this will be removed in 2.1.*
tmpl_context.menu_items = self.menu_items
tmpl_context.title = self.title
def __init__(self, session, menu_items=None):
if menu_items is None:
menu_items = {}
self.menu_items = menu_items
self.provider = ProviderTypeSelector().get_selector(self.model).get_provider(self.model, hint=session)
self.session = session
#this makes crc declarative
check_types = ['new_form', 'edit_form', 'table', 'table_filler', 'edit_filler']
for type_ in check_types:
if not hasattr(self, type_) and hasattr(self, type_+'_type'):
setattr(self, type_, getattr(self, type_+'_type')(self.session))
if hasattr(self, 'new_form'):
#register the validators since they are none from the parent class
register_validators(self, 'post', self.new_form)
if hasattr(self, 'edit_form'):
register_validators(self, 'put', self.edit_form)
@with_trailing_slash
@expose('tgext.crud.templates.get_all')
@expose('json')
@paginate('value_list', items_per_page=7)
def get_all(self, *args, **kw):
"""Return all records.
Pagination is done by offset/limit in the filler method.
Returns an HTML page with the records if not json.
"""
if pylons.request.response_type == 'application/json':
return self.table_filler.get_value(**kw)
if not getattr(self.table.__class__, '__retrieves_own_value__', False):
values = self.table_filler.get_value(**kw)
else:
values = []
tmpl_context.widget = self.table
return dict(model=self.model.__name__, value_list=values)
@expose('tgext.crud.templates.get_one')
@expose('json')
def get_one(self, *args, **kw):
"""get one record, returns HTML or json"""
#this would probably only be realized as a json stream
tmpl_context.widget = self.edit_form
pks = self.provider.get_primary_fields(self.model)
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
return dict(value=value,model=self.model.__name__)
@expose('tgext.crud.templates.edit')
def edit(self, *args, **kw):
log.debug('editFase: %s' %kw)
"""Display a page to edit the record."""
tmpl_context.widget = self.edit_form
pks = self.provider.get_primary_fields(self.model)
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
value['_method'] = 'PUT'
return dict(value=value, model=self.model.__name__, pk_count=len(pks))
@without_trailing_slash
@expose('sap.templates.desarrollar.fase.new')
def new(self,pid=None,value2=None, *args, **kw):
"""Display a page to show a new record."""
tmpl_context.widget = self.new_form
kw['idproyec']=pid
log.debug('KWNew=%s' %tmpl_context.widget)
#return dict(value=kw, model=self.model.__name__)
return dict(value={'idproyec':pid},value2=kw, model=self.model.__name__)
@catch_errors(errors, error_handler=new)
@expose()
@registered_validate(error_handler=new)
def post(self, *args, **kw):
###imprimir
log.debug('kwww= %s' %kw['idproyec'])
####
self.provider.create(self.model, params=kw)
#raise redirect('./')
raise redirect('./?pid='+kw['idproyec'])
@expose()
@registered_validate(error_handler=edit)
@catch_errors(errors, error_handler=edit)
def put(self, *args, **kw):
"""update"""
pks = self.provider.get_primary_fields(self.model)
for i, pk in enumerate(pks):
if pk not in kw and i < len(args):
kw[pk] = args[i]
self.provider.update(self.model, params=kw)
redirect('../' * len(pks))
@expose()
def post_delete(self, *args, **kw):
"""This is the code that actually deletes the record"""
pks = self.provider.get_primary_fields(self.model)
d = {}
for i, arg in enumerate(args):
d[pks[i]] = arg
self.provider.delete(self.model, d)
redirect('./' + '../' * (len(pks) - 1))
@expose('tgext.crud.templates.get_delete')
def get_delete(self, *args, **kw):
"""This is the code that creates a confirm_delete page"""
return dict(args=args)
class CrudRestController(RestController):
"""
:variables:
session
database session (drives drop-down menus
menu_items
Dictionary of links to other models in the form model_items[lower_model_name] = Model
title
Title to be used for each page. default: Turbogears Admin System
:modifiers:
model
Model this class is associated with
table
Widget for the table display
table_filler
Class instance with get_value() that defines the JSon stream for the table
edit_form
Form to be used for editing the model
edit_filler
Class instance with a get_value() that defines how we get information for a single
existing record
new_form
Form that defines how we create a form for new data entry.
:Attributes:
menu_items
Dictionary of associated Models (used for menu)
provider
sprox provider for data manipulation
session
link to the database
"""
title = "Turbogears Admin System"
def _before(self, *args, **kw):
tmpl_context.title = self.title
tmpl_context.menu_items = self.menu_items
def __before__(self, *args, **kw):
# this will be removed in 2.1.*
tmpl_context.menu_items = self.menu_items
tmpl_context.title = self.title
def __init__(self, session, menu_items=None):
if menu_items is None:
menu_items = {}
self.menu_items = menu_items
self.provider = ProviderTypeSelector().get_selector(
self.model).get_provider(self.model, hint=session)
self.session = session
#this makes crc declarative
check_types = [
'new_form', 'edit_form', 'table', 'table_filler', 'edit_filler'
]
for type_ in check_types:
if not hasattr(self, type_) and hasattr(self, type_ + '_type'):
setattr(self, type_,
getattr(self, type_ + '_type')(self.session))
if hasattr(self, 'new_form'):
#register the validators since they are none from the parent class
register_validators(self, 'post', self.new_form)
if hasattr(self, 'edit_form'):
register_validators(self, 'put', self.edit_form)
@with_trailing_slash
@expose('tgext.crud.templates.get_all')
@expose('json')
@paginate('value_list', items_per_page=7)
def get_all(self, *args, **kw):
"""Return all records.
Pagination is done by offset/limit in the filler method.
Returns an HTML page with the records if not json.
"""
if pylons.request.response_type == 'application/json':
return self.table_filler.get_value(**kw)
if not getattr(self.table.__class__, '__retrieves_own_value__', False):
values = self.table_filler.get_value(**kw)
else:
values = []
tmpl_context.widget = self.table
return dict(model=self.model.__name__, value_list=values)
@expose('tgext.crud.templates.get_one')
@expose('json')
def get_one(self, *args, **kw):
"""get one record, returns HTML or json"""
#this would probably only be realized as a json stream
tmpl_context.widget = self.edit_form
pks = self.provider.get_primary_fields(self.model)
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
return dict(value=value, model=self.model.__name__)
@expose('tgext.crud.templates.edit')
def edit(self, *args, **kw):
"""Display a page to edit the record."""
tmpl_context.widget = self.edit_form
pks = self.provider.get_primary_fields(self.model)
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
value['_method'] = 'PUT'
return dict(value=value, model=self.model.__name__, pk_count=len(pks))
@without_trailing_slash
@expose('tgext.crud.templates.new')
def new(self, *args, **kw):
"""Display a page to show a new record."""
tmpl_context.widget = self.new_form
return dict(value=kw, model=self.model.__name__)
@catch_errors(errors, error_handler=new)
@expose()
@registered_validate(error_handler=new)
def post(self, *args, **kw):
self.provider.create(self.model, params=kw)
raise redirect('./')
@expose()
@registered_validate(error_handler=edit)
@catch_errors(errors, error_handler=edit)
def put(self, *args, **kw):
"""update"""
pks = self.provider.get_primary_fields(self.model)
for i, pk in enumerate(pks):
if pk not in kw and i < len(args):
kw[pk] = args[i]
self.provider.update(self.model, params=kw)
redirect('../' * len(pks))
@expose()
def post_delete(self, *args, **kw):
"""This is the code that actually deletes the record"""
pks = self.provider.get_primary_fields(self.model)
d = {}
for i, arg in enumerate(args):
d[pks[i]] = arg
self.provider.delete(self.model, d)
redirect('./' + '../' * (len(pks) - 1))
@expose('tgext.crud.templates.get_delete')
def get_delete(self, *args, **kw):
"""This is the code that creates a confirm_delete page"""
return dict(args=args)
class CrudRestController(RestController):
"""
:variables:
session
database session (drives drop-down menus
menu_items
Dictionary of links to other models in the form model_items[lower_model_name] = Model
title
Title to be used for each page. default: Turbogears Admin System
:modifiers:
model
Model this class is associated with
table
Widget for the table display
table_filler
Class instance with get_value() that defines the JSon stream for the table
edit_form
Form to be used for editing the model
edit_filler
Class instance with a get_value() that defines how we get information for a single
existing record
new_form
Form that defines how we create a form for new data entry.
:Attributes:
menu_items
Dictionary of associated Models (used for menu)
provider
sprox provider for data manipulation
session
link to the database
"""
title = "Turbogears Admin System"
def _before(self, *args, **kw):
tmpl_context.title = self.title
tmpl_context.menu_items = self.menu_items
def __before__(self, *args, **kw):
# this will be removed in 2.1.*
tmpl_context.menu_items = self.menu_items
tmpl_context.title = self.title
def __init__(self, session, menu_items=None):
if menu_items is None:
menu_items = {}
self.menu_items = menu_items
self.provider = ProviderTypeSelector().get_selector(self.model).get_provider(self.model, hint=session)
self.session = session
#this makes crc declarative
check_types = ['new_form', 'edit_form', 'table', 'table_filler', 'edit_filler']
for type_ in check_types:
if not hasattr(self, type_) and hasattr(self, type_+'_type'):
setattr(self, type_, getattr(self, type_+'_type')(self.session))
if hasattr(self, 'new_form'):
#register the validators since they are none from the parent class
register_validators(self, 'post', self.new_form)
if hasattr(self, 'edit_form'):
register_validators(self, 'put', self.edit_form)
@with_trailing_slash
@expose('tgext.crud.templates.get_all')
@expose('json')
@paginate('value_list', items_per_page=7)
def get_all(self, *args, **kw):
"""Return all records.
Pagination is done by offset/limit in the filler method.
Returns an HTML page with the records if not json.
"""
if pylons.request.response_type == 'application/json':
return self.table_filler.get_value(**kw)
if not getattr(self.table.__class__, '__retrieves_own_value__', False):
values = self.table_filler.get_value(**kw)
else:
values = []
tmpl_context.widget = self.table
return dict(model=self.model.__name__, value_list=values)
@expose('tgext.crud.templates.get_one')
@expose('json')
def get_one(self, *args, **kw):
"""get one record, returns HTML or json"""
#this would probably only be realized as a json stream
tmpl_context.widget = self.edit_form
pks = self.provider.get_primary_fields(self.model)
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
return dict(value=value,model=self.model.__name__)
@expose('sap.templates.desarrollar.detalleitem.edit')
def edit(self, *args, **kw):
"""Display a page to edit the record."""
tmpl_context.widget = self.edit_form
#pks = self.provider.get_primary_fields(self.model)
###########################################
pks = self.provider.get_primary_fields(self.model)
###########################################
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
value['_method'] = 'PUT'
return dict(value=value, model=self.model.__name__, pk_count=len(pks))
@without_trailing_slash
@expose('sap.templates.desarrollar.detalleitem.new')
def new(self,iid=None ,*args, **kw):
"""Se obtiene el id del tipo de item elegido para el item"""
idtipo=DBSession.query(Item.idTipoDeItem).filter_by(id=iid).first()
atributos= [x for x in (DBSession.query(Campos.nombre, Campos.nombre).filter_by(idTipoDeItem=idtipo))]
tmpl_context.widget = self.new_form
return dict(value={'iditem':iid}, model=self.model.__name__, atributos_options=atributos)
@catch_errors(errors, error_handler=new)
@expose()
@registered_validate(error_handler=new)
def post(self, *args, **kw):
yaExiste= DBSession.query(DetalleItem.nombrecampo).filter_by(nombrecampo=kw['nombrecampo'],iditem=kw['iditem']).first()
#log.debug("yaExite: %s" %yaExite)
#longitud= len(yaExite)
#log.debug("longitud= %s" %longitud)
if yaExiste == None:
self.provider.create(self.model, params=kw)
else:
flash("Atributo cargado", 'error')
redirect('/detalleitem/new/?iid='+ kw['iditem'])
raise redirect('/detalleitem/?iid='+ kw['iditem'])
@expose()
@registered_validate(error_handler=edit)
@catch_errors(errors, error_handler=edit)
def put(self, *args, **kw):
"""update"""
pks = self.provider.get_primary_fields(self.model)
for i, pk in enumerate(pks):
if pk not in kw and i < len(args):
kw[pk] = args[i]
#self.provider.update(self.model, params=kw)
log.debug('detalleEditado: %s' %kw)
detalleitem = DBSession.query(DetalleItem).filter_by(id=kw['id']).first()
if str(detalleitem.tipo).__eq__('integer'):
try:
int(kw['valor'])
except:
flash('\"' + str(detalleitem.nombrecampo) + '\". Debe ingresar un entero', 'error')
redirect('../'+kw['id']+'/edit')
elif str(detalleitem.tipo).__eq__('date'):
"""False = fecha no valida
True = fecha valida"""
if not (self.fechaValida(kw['valor'])):
flash('\"' + str(detalleitem.nombrecampo) + '\" Fecha no valida. Formato: dd/mm/aaaa', 'error')
redirect('../'+kw['id']+'/edit')
else:
if kw['valor'].__eq__(''):
flash('\"' + str(detalleitem.nombrecampo) + '\" no puede ser vacio', 'error')
redirect('../'+kw['id']+'/edit')
"""-----------Se obtiene el ID item a editado-------------"""
iid=DBSession.query(DetalleItem.iditem).filter_by(id=kw[pk]).first()
"""Se crea un nuevo item"""
itemeditado=DBSession.query(Item).filter_by(id=iid).first()
itemnuevo=Item()
itemnuevo.version=itemeditado.version + 1
itemnuevo.idTipoDeItem=itemeditado.idTipoDeItem
itemnuevo.idFase=itemeditado.idFase
itemnuevo.idLineaBase=itemeditado.idLineaBase
itemnuevo.fechaCreacion=itemeditado.fechaCreacion
itemnuevo.nrohistorial=itemeditado.nrohistorial
itemnuevo.ultimaversion=1
itemeditado.ultimaversion=0
itemnuevo.estado='modificado'
itemnuevo.complejidad=itemeditado.complejidad
itemnuevo.nombre=itemeditado.nombre
DBSession.add(itemnuevo)
"""Realiza copia de los valores de los atributos especificos"""
atributoeditado=DBSession.query(DetalleItem).filter_by(iditem=itemeditado.id).all()
for objeto in atributoeditado:
nuevoDetalle=DetalleItem()
nuevoDetalle.tipo=objeto.tipo
nuevoDetalle.nombrecampo=objeto.nombrecampo
if str(objeto.id)==str(kw[pk]):
nuevoDetalle.valor=kw['valor']
else:
nuevoDetalle.valor=objeto.valor
nuevoDetalle.iditem=itemnuevo.id
DBSession.add(nuevoDetalle)
"""Realiza copia de los adjuntos"""
adjuntositemeditado=DBSession.query(Adjuntos).filter_by(idItem=itemeditado.id).all()
for adj in adjuntositemeditado:
itemnuevoadjunto=Adjuntos()
itemnuevoadjunto.idItem=itemnuevo.id
itemnuevoadjunto.filename=adj.filename
itemnuevoadjunto.filecontent=adj.filecontent
DBSession.add(itemnuevoadjunto)
"""Copia las relaciones """
relaciones = DBSession.query(RelacionItem.idItem1,RelacionItem.idItem2).filter((RelacionItem.idItem2==itemeditado.id) | (RelacionItem.idItem1==itemeditado.id)).all()
longitud = len(relaciones)
newRelation=RelacionItem()
for x in range(longitud):
if int(itemeditado.id) == int(relaciones[x][0]):
newRelation.idItem1=int(itemnuevo.id)
newRelation.idItem2=relaciones[x][1]
DBSession.add(newRelation)
#self.provider.create(RelacionItem, params=newRelation)
elif int(itemeditado.id) == int(relaciones[x][1]):
newRelation.idItem1=relaciones[x][0]
newRelation.idItem2=int(itemnuevo.id)
DBSession.add(newRelation)
#detalleitem/?iid=113
redirect('../?iid=' + str(itemnuevo.id) )
@expose()
def post_delete(self, *args, **kw):
"""This is the code that actually deletes the record"""
pks = self.provider.get_primary_fields(self.model)
d = {}
for i, arg in enumerate(args):
d[pks[i]] = arg
self.provider.delete(self.model, d)
redirect('./' + '../' * (len(pks) - 1))
@expose('tgext.crud.templates.get_delete')
def get_delete(self, *args, **kw):
"""This is the code that creates a confirm_delete page"""
return dict(args=args)
def fechaValida (self, fecha):
if fecha.__eq__(''):
return False
longfecha = len(fecha)
if longfecha != 10:
return False
if str(fecha[2]) != '/':
return False
if str(fecha[5]) != '/':
return False
dia = fecha[0] + fecha[1]
mes = fecha [3] + fecha [4]
anho = fecha [6] + fecha [7] + fecha [8] + fecha [9]
try:
dia = int(dia)
mes = int(mes)
anho = int(anho)
except:
return False
meses = {'1':31, '2':28, '3':31, '4':30, '5':31, '6':30,
'7':31, '8':31, '9':30, '10':31, '11':30, '12':31}
if 1900 < anho < 9999:
if (anho % 4) == 0:
meses['2'] = 29
if 0 < mes < 13:
if 0 < dia <= meses[str(mes)]:
return True
else:
return False
else:
return False
else:
return False
