def get_usuarios_by_fase(self, id, permiso_name='ver_fase'):
		"""
		Obtiene una lista de los usuarios que poseen el permiso especificado sobre
		un proyecto.

		@type  id  : Integer
		@param id  : Identificador de la fase

		@type  permiso_name : String
		@param permiso_name : Nombre del permiso

		@rtype  : Usuario []
		@return : Lista de usuarios que poseen el permiso sobre la fase
		"""
		usuarios = DBSession.query(Usuario).\
					filter(UsuarioPermisoFase.usuario_id == Usuario.usuario_id).\
					filter(UsuarioPermisoFase.fase_id == id).\
					filter(UsuarioPermisoFase.permiso_id == Permiso.permiso_id).\
					filter(Permiso.nombre == permiso_name).all()
		#Si el usuairo es lider del proyecto se saltan los controles
		user = checker.get_current_user()
		fase = DBSession.query(Fase).get(id)
		rol = self.get_rol_by_codigo('lider_' + str(fase.proyecto))

		if self.usuario_has_rol(user.usuario_id, rol ):
			usuarios.append(user)

		return self.distinct(usuarios)

	def post(self, args={}, **kw):
		"""
		Evento invocado luego de un evento post en el form de crear
		ecargado de persistir las nuevas instancias.

		@type  args : Hash
		@param args : Argumentos de template

		@type  kw : Hash
		@param kw : Keywords

		"""

		del kw['sprox_id']
		rol = Rol()
		rol.codigo = kw['codigo']
		rol.nombre = kw['nombre']
		rol.descripcion = kw['descripcion']

		for permiso in kw['permisos'] :
			rol.permisos.append(DBSession.query(Permiso).get(permiso))

		DBSession.add(rol)
		flash("El rol ha sido creado correctamente.")
		redirect("/administracion/rol/get_all")

	def borrarRelacion(self, item1, item2, idfase, **kw):

		if not self.puede_borrar(item1, item2, idfase):
			flash ("No se peude borrar la relacion! deja huerfanos", 'warning')
			redirect("/miproyecto/fase/relacion/list/"+idfase)

		#auditar items y aumentar su version
		item_1 = DBSession.query(Item).get(item1)
		item_2 = DBSession.query(Item).get(item2)

		item_util.audit_item(item_1)
		item_util.audit_item(item_2)

		item_1.version += 1
		item_2.version += 1

		item_1.estado = 3
		item_2.estado = 3

		DBSession.add(item_1)
		DBSession.add(item_2)

		DBSession.delete(DBSession.query(RelacionItem).\
					filter(RelacionItem.id_item_actual==item1).\
					filter(RelacionItem.id_item_relacionado==item2).\
					one())

		#marcar en revision los relacionados
		fase = DBSession.query(Fase).get(item_1.fase)
		grafo = item_util.proyectGraphConstructor(fase.proyecto)
		item_util.marcar_en_revision(grafo, item_1.id_item)
		item_util.marcar_en_revision(grafo, item_2.id_item)

		flash("Se ha eliminado la relacion: "+item1+" <--> "+item2)
		redirect("/miproyecto/fase/relacion/list/"+idfase)

    def _do_get_provider_count_and_objs(self, **kw):
        limit = kw.get('limit', None)
        offset = kw.get('offset', None)
        order_by = kw.get('order_by', None)
        desc = kw.get('desc', False)
        #objs = DBSession.query(self.__entity__).filter_by(idFase=1).all()
        
        if len(kw) > 0:
            if len(kw) > 1:
                #objs = DBSession.query(self.__entity__).filter((Fase.idproyec==kw['pid']) & (Fase.nombre.ilike('%'+str(kw['buscar'])+'%'))).all()

                if kw['buscar']=="":
                    objs = DBSession.query(self.__entity__).filter_by(nrohistorial=kw['hid'], ultimaversion=0).all()
                else:
                    objs = DBSession.query(self.__entity__).filter((Item.nrohistorial==kw['hid'])& (Item.ultimaversion==0) & (Item.version ==kw['buscar'])).all()
                

            else:
                
                objs = DBSession.query(self.__entity__).filter_by(nrohistorial=kw['hid'], ultimaversion=0).all()
        else:
            
            objs = DBSession.query(self.__entity__).all()

        count = len(objs)
        self.__count__ = count
        return count, objs    

 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]
     
     idTipoDeItem=DBSession.query(Campos.idTipoDeItem).filter_by(id=kw['id']).first()
     
     
     
     if kw['nombre']==None:
         flash("El nuevo Atributo debe tener un nombre" , "error")
         redirect('../'+ kw['id'] +'/edit')
     
     
     nombreduplicado=DBSession.query(Campos.nombre).filter((Campos.idTipoDeItem==idTipoDeItem) &(Campos.id != kw['id']) &(Campos.nombre==kw['nombre'])).first()
     
     if nombreduplicado != None :
         flash("Ya existe un Atributo con el mismo nombre" , "error")
         redirect('../'+ kw['id'] +'/edit')
         
         
     self.provider.update(self.model, params=kw)
     idtipo=DBSession.query(Campos.idTipoDeItem).filter_by(id=kw[pk]).first()
     
     redirect('../?tid=' + str(idtipo[0]))

	def put(self, id, **kw):
		"""
		Evento invocado luego de un evento post en el form de editar
		ecargado de persistir las modificaciones de las instancias.

		@type  id : Integer
		@param id : Identificador del usuario.

		@type  kw : Hash
		@param kw : Keywords

		"""

		usuario = DBSession.query(Usuario).get( int(id) )

		usuario.nombre = kw['nombre']
		usuario.email_address = kw['email_address']

		if usuario._password != kw['password'] :
			print 'Actualizando la contrasenha'
			usuario._set_password(kw['password'])

		DBSession.merge(usuario)
		flash("El usuario '"+usuario.nombre+"' ha sido modificado correctamente.")
		redirect("/administracion/usuario/get_all")

 def __actions__(self, obj):
     """Override this function to define how action links should be displayed for the given record."""
     primary_fields = self.__provider__.get_primary_fields(self.__entity__)
     pklist = '/'.join(map(lambda x: str(getattr(obj, x)), primary_fields))
     #if has_permission('manage'):############
     proyecto = DBSession.query(Fase.idproyec).filter_by(id = pklist).first()
     estado = DBSession.query(Proyecto.estado).filter_by(id = proyecto).first()
     value='<div></div>'
     
     if str(estado[0]).__eq__("nuevo"):
         value = '<div><div><a class="edit_link" href="'+pklist+'/edit" style="text-decoration:none">edit</a></div>'\
         '<div><form method="POST" action="'+pklist+'" class="button-to">'\
         '<input type="hidden" name="_method" value="DELETE" />'\
         '<input class="delete-button" onclick="return confirm(\'Are you sure?\');" value="delete" type="submit" '\
         'style="background-color: transparent; float:left; border:0; color: #286571; display: inline; margin: 0; padding: 0;"/>'\
         '</form>'\
         '</div>''</div>'
         
     elif str(estado[0]).__eq__("iniciado"):
         value = '<div><div><a class="edit_link" href="'+pklist+'/edit" style="text-decoration:none">edit</a>'\
         '<div><a class="loginlogout" href="/tipodeitem/?fid='+pklist+ '">TiposItem</a></div><br/>'\
         '<div><a class="loginlogout" href="/importartipodeitem/new/?fid='+pklist+ '">ImportarTipoItem</a></div><br/>'\
         '</div></div>'
     
     return value

    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'])

	def new(self, idtipo, args={}, **kw):
		"""
		Encargado de cargar el widget para crear nuevas instancias,
		solo tienen acceso aquellos usuarios que posean el premiso de crear

		@type  idtipo : Integer
		@param idtipo : Identificador del Atributo del item.

		@type  args : Hash
		@param args : Argumentos de template

		@type  kw : Hash
		@param kw : Keywords

		@rtype  : Diccionario
		@return : El diccionario que sera utilizado en el template.

		"""

		tmpl_context.widget = new_atributo_form
		self.params['modelname'] = "Atributos del Tipo de Item"
		self.params['idtipo'] = idtipo
		self.params['tipo_item'] = DBSession.query(TipoItem).get(idtipo)
		self.params['current_name'] = self.params['tipo_item'].nombre
		id_fase = self.params['tipo_item'].fase
		self.params['fase'] = DBSession.query(Fase).get(id_fase)
		self.params['idfase'] = id_fase
		self.params['header_file'] = 'tipo_item'
		self.params['cancelar_url'] = '/miproyecto/fase/tipo_item/atributos/list/'+str(idtipo)
		return dict(value=kw, params=self.params)

	def get_all(self, idfase, **kw):
		"""Lista todos los items de la fase"""

		has_permiso = session_util.authorize_fase('ver_fase', idfase)
		if ( has_permiso == None) :
			flash("No posee permisos sobre la fase #"+str(idfase),'error')
			redirect('/miproyecto/fase/error')


		tmpl_context.widget = item_table
		items = DBSession.query(Item).filter(Item.fase==idfase).all()
		value = item_filler.get_value(items)

		permiso_editar = fase_util.check_fase_permiso(idfase, 'editar_fase')
		permiso_anadir = fase_util.check_fase_permiso(idfase, 'administrar_participantes')

		self.params['title'] = 'Titulo'
		self.params['permiso_editar'] = permiso_editar
		self.params['permiso_anadir'] = permiso_anadir
		self.params['modelname'] = 'Items'
		self.params['header_file'] = 'fase'
		self.params['permiso'] = 'crear_item'
		self.params['idfase'] = idfase
		self.params['fase'] = DBSession.query(Fase).get(idfase)
		self.params['new_url'] = '/miproyecto/fase/item/'+idfase+'/new/'
		self.params['label'] = 'Agregar Atributo'
		self.params['usuarios'] = usuario_util.get_usuarios_by_fase(idfase)

		return dict(value=value, params = self.params)

	def importar_este_tipo(self, idtipo, idfase):
		"""
		Se obtiene de la BD el tipo de item y sus atributos
		"""
		tipo = DBSession.query(TipoItem).get(idtipo)
		atributos = DBSession.query(AtributoTipoItem).\
						filter(AtributoTipoItem.tipo_item==tipo.id_tipo_item)
		"""
		Se settean los valores de la copia
		El nuevo tipo de item (copia_tipo )pertenecera a esta fase ahora
		"""
		copia_tipo = TipoItem()
		copia_tipo.nombre = tipo.nombre
		copia_tipo.descripcion = tipo.descripcion
		copia_tipo.fase = idfase
		copia_tipo.codigo = tipo.codigo
		'''
		Se settean los valores para cada copia_atributo
		'''
		for atributo in atributos:
			copia_atributo = AtributoTipoItem()
			copia_atributo.nombre = atributo.nombre
			copia_atributo.tipo_id = atributo.tipo_id
			copia_tipo.atributos.append(copia_atributo)

		DBSession.add(copia_tipo)
		flash("El tipo de item "+str(tipo.nombre)+
										" pertenece ahora a esta fase")
		redirect("/miproyecto/fase/tipo_item/importar/"+str(idfase))

	def iniciar_proyecto(self, idproyecto, **kw):
		proyecto = DBSession.query(Proyecto).get(idproyecto)
		proyecto.estado = estado_proyecto_util.get_by_codigo('Desarrollo')

		DBSession.merge(proyecto)

		redirect('/miproyecto/ver/'+str(idproyecto))

	def revivir_item (self, historial_item):
		"""
		Restaura el item a su ultima version sin sus relaciones
		"""
		item = Item()
		item.id_item = historial_item.id_item
		item.nombre = historial_item.nombre
		item.codigo = historial_item.codigo
		#el estado del item es en desarrollo al revivir
		item.estado = 2
		item.tipo_item = historial_item.tipo_item
		item.fase = historial_item.fase
		item.version = historial_item.version
		item.prioridad = historial_item.prioridad
		item.complejidad = historial_item.complejidad
		item.descripcion = historial_item.descripcion
		item.observacion = historial_item.observacion
		item.linea_base = historial_item.linea_base

		#recuperar los detalles
		historial_detalles = DBSession.query(HistorialDetalleItem).\
			filter(HistorialDetalleItem.id_item==historial_item.id_item).\
			all()

		for hist_detalle in historial_detalles:
			detalle = DetalleItem()
			detalle.id_detalle = hist_detalle.id_detalle
			detalle.id_item = hist_detalle.id_item
			detalle.recurso = hist_detalle.recurso
			detalle.valor = hist_detalle.valor
			item.detalles.append(detalle)

		DBSession.merge(item)

    def _do_get_provider_count_and_objs(self, **kw):
        limit = kw.get('limit', None)
        offset = kw.get('offset', None)
        order_by = kw.get('order_by', None)
        desc = kw.get('desc', False)
        
        

        idUsuario= [x for x in DBSession.query(User.user_id).filter_by(user_name=request.identity['repoze.who.userid'])]
        
        idProy=[x for x in DBSession.query(ProyFaseUsuario.idProyecto).filter_by(iduser=idUsuario[0]).distinct()] 
        proyectos=[]
        
        longitud=len(idProy)
        for y in range(longitud):
            proyectos.append(DBSession.query(self.__entity__).filter_by(id = idProy[y]).one())

        
        if len(kw) > 0:
            
            for y in range(longitud):
                proyectos.append(DBSession.query(self.__entity__).filter((Proyecto.id == idProy[y]) & (Proyecto.nombre.ilike('%'+str(kw['buscar'])+'%'))).one())
            
            objs =proyectos 
            
        else:
            objs = proyectos
        
        
                
        
        
        count = len(objs)
        self.__count__ = count
        return count, objs    

	def faseGraphConstructor(self, idfase):
		#lista de items para el grafo
		items = DBSession.query(Item).filter(Item.fase==idfase).all()
		itemsId = []

		"""
		Todos los items de la fase forman parte del grafo (item = nodo)
		"grafo" es un grafo dirigido que representa las relaciones padre-hijo
		en una fase.
		"""
		grafo = digraph()
		for item in items:
			grafo.add_nodes([item.id_item])

		"""
		Se busca en la tabla RelacionItem todas las relaciones de padre-hijo
		que contengan a los items de la fase
		"""
		#guardar los ids de los items
		for item in items:
			itemsId = itemsId + [item.id_item]

		relaciones = DBSession.query(RelacionItem).\
						filter(RelacionItem.relacion_parentesco==1).\
						filter(RelacionItem.id_item_actual.in_(itemsId)).\
						filter(RelacionItem.id_item_relacionado.in_(itemsId)).\
						all()

		#Se añaden las aristas entre los items relacionados
		for relacion in relaciones:
			grafo.add_edge((relacion.id_item_actual, relacion.id_item_relacionado))

		return grafo

	def put(self, args={}, **kw):
		"""
		Evento invocado luego de un evento post en el form de editar
		ecargado de persistir las modificaciones de las instancias.

		@type  args : Hash
		@param args : Argumentos de template

		@type  kw : Hash
		@param kw : Keywords

		"""
		del kw['sprox_id']
		rol = DBSession.query(Rol).get(int(kw['rol_id']))
		rol.nombre = kw['nombre']
		rol.codigo = kw['codigo']
		rol.descripcion = kw['descripcion']
		rol.is_template = kw['is_template']
		rol.permisos = []

		for permiso_id in kw['permisos'] :
			rol.permisos.append(DBSession.query(Permiso).get(permiso_id))

		DBSession.merge(rol)
		flash("El rol '"+rol.nombre+"' ha sido modificado correctamente.")
		redirect("/administracion/rol/get_all")

	def put(self, args={}, **kw):
		"""
		Evento invocado luego de un evento post en el form de editar
		ecargado de persistir las modificaciones de las instancias.

		@type  args : Hash
		@param args : Argumentos de template

		@type  kw : Hash
		@param kw : Keywords

		"""
		#Se obtiene de la base de datos el proyecto modifcado
		proyecto = DBSession.query(Proyecto).get(int(kw['id_proyecto']))
		#Se actualizan unicamente los campos actualizables
		proyecto.nombre=kw['nombre']
		proyecto.nro_fases = kw['nro_fases']
		proyecto.descripcion = kw['descripcion']

		#asignar lider
		proyecto.lider = DBSession.query(Usuario).get(kw['lider'])
		util.asignar_lider(proyecto)

		DBSession.merge(proyecto)
		flash("El proyecto ha sido '" +proyecto.nombre+ "' modificado correctamente.")
		redirect("/administracion/proyecto/list")

	def asignar_rol_usuario(self,usuario_id , cod_rol, id_proyecto):
		"""
		Asigna un rol asociado a un proyecto al usuario determinado.

		@type  usuario_id  : Integer
		@param usuario_id  : Identificador del usuario

		@type  cod_rol    : String
		@param cod_rol    : Codigo del rol

		@type  id_proyecto : Integer
		@param id_proyecto : Identificador del proyecto al cual se va aplicar el rol

		@rtype  : Rol
		@return : El rol que es asignado al usuario.
		"""
		#Se obtiene el rol con el nombre correspondiente
		rol = rol_util.get_by_codigo(cod_rol)
		#Se verifica si el usuario posee el rol
		rol_usuario = usuario_util.usuario_has_rol(usuario_id, rol)
		#si no posee el rol, se le asigna
		if rol_usuario == None:
			rol_usuario = RolUsuario()
			rol_usuario.usuario_id = usuario_id
			rol_usuario.rol_id = rol.rol_id

			DBSession.add(rol_usuario)

		return rol

	def proyectGraphConstructor(self, idproyecto):
		fases = DBSession.query(Fase).filter(Fase.proyecto==idproyecto).all()
		grafo = digraph()
		items = []
		itemsId = []

		#se "obtienen los items de cada fase
		for fase in fases:
			items = items + list(DBSession.query(Item).filter(Item.fase==fase.id_fase))

		for item in items:
			grafo.add_nodes([item.id_item])

		#guardar los ids de los items
		for item in items:
			itemsId = itemsId + [item.id_item]
 		"""
		Se busca en la tabla RelacionItem todas las relaciones
		que contengan a los items del proyecto
		"""
		relaciones = DBSession.query(RelacionItem).\
						filter((RelacionItem.id_item_actual).in_(itemsId)).\
						all()

		#Se añaden las aristas entre los items relacionados
		for relacion in relaciones:
			grafo.add_edge((relacion.id_item_actual,relacion.id_item_relacionado))


		return grafo

	def gen_cod (self, id_fase, id_tipo):
		#traer la fase
		fase_actual = DBSession.query(Fase).get(id_fase)

		#se consulta por el numero de la fase actual dentro del proyecto
		nro_fase = 1 + len(DBSession.query(Fase).\
						filter(Fase.proyecto==fase_actual.proyecto).\
						filter(Fase.id_fase<fase_actual.id_fase).\
						all())

		#cantidad de items + 1 es el nro de item del nuevo item
		#dentro del proyecto actual
		nro_item = 1 + len(DBSession.query(Item).\
								filter(Item.fase==fase_actual.id_fase).\
								all())

		#obtener el tipo de item al cual corresponde el item, el codigo
		#de este es utilizado como prefijo del codigo del item
		tipo = DBSession.query(TipoItem).get(id_tipo)
		prefijo = tipo.codigo

		#se concatenan los resultados
		item_codigo = prefijo + str(nro_fase) + str(nro_item)

		return item_codigo