def list(self, id_fase):
		
		identity = request.environ.get('repoze.who.identity')
		if identity is not None:
			user = identity.get('user')
		idi = user.id_usuario
		
		rol_lider = DBSession.query(RolUsuario).filter(RolUsuario.id_usuario==idi).\
				filter(Rol.group_name=="lider").filter(Rol.id_rol == RolUsuario.id_rol).all()
		
		if(len(rol_lider)==0):
			listar = DBSession.query(Usperfa).filter(Usperfa.id_fase==id_fase).\
											filter(Permiso.permission_name=="ver_linea_base").\
											filter(Usperfa.id_permiso==Permiso.id_permiso).\
											filter(RolUsuario.id_usuario==idi).all()
			if (len(listar)==0):
				flash("No posee los permisos para ver las lineas bases",'error')
				redirect("/configuracion/linea_base/error")
			else:
				self.id_fase = id_fase
				fase = DBSession.query(Fase).get(id_fase)
				tmpl_context.widget = list_lineabase
				value = list_lineabase_filler.get_value(id_fase=id_fase)
		else:
			self.id_fase = id_fase
			fase = DBSession.query(Fase).get(id_fase)
			tmpl_context.widget = list_lineabase
			value = list_lineabase_filler.get_value(id_fase=id_fase)
		return dict(fase=fase, value=value)

    def assign_license(self, **kwargs):

        user_name = request.identity['repoze.who.userid']
        user_id = DBSession.query(model.User.user_id).filter(model.User.user_name==user_name).first().user_id

        #Report if computer or license don't belong to user who is logged in and available > 0
        if DBSession.query(model.Computer).filter(model.Computer.id==kwargs['computer'], model.Computer.user_id==user_id).count() < 1  or DBSession.query(model.License).filter(model.License.id==kwargs['license'], model.License.user_id==user_id).count() < 1 or DBSession.query(model.License.available).filter(model.License.id==kwargs['license'], model.License.user_id==user_id).first().available < 1:
            flash(('This incident has been reported'), 'error')
            redirect('/manage')

        a = model.Assignment()
        a.user_id = user_id
        a.license_id = kwargs['license']
        a.computer_id = kwargs['computer']
        a.count = 1
        a.locked = False

        model.DBSession.add(a)

        license = DBSession.query(model.License).filter(model.License.id==a.license_id).first()
        license.available = license.available - a.count


        model.DBSession.flush()

        flash("Assignment added.")
        redirect('/manage')

 def delete(self, id, **kw):
    ''' Delete department from DB
    '''
    log.info('delete ' + kw['_id'])
    DBSession.delete(DBSession.query(Department).get(kw['_id']))
    flash(u'Service supprimé', 'notice')
    redirect('/departments/')

    def set_exfeed(self, new_exfeed=None, **kw):
        exfeed_val = kw.get('exfeed', [])
        if type(exfeed_val) == unicode:
            tmp_exfeed_list = []
            tmp_exfeed_list.append(exfeed_val)
        else:
            tmp_exfeed_list = exfeed_val

        if new_exfeed is not None and new_exfeed != '':
            tmp_exfeed_list.append(new_exfeed)

        exfeed_list = []
        invalid_list = []
        v = validators.URL()
        for link in tmp_exfeed_list:
            try:
                v.to_python(link)
                exfeed_list.append(link)
            except formencode.api.Invalid:
                invalid_list.append(link)

        self.app.external_feeds_list = exfeed_list
        flash('External feeds updated')
        if len(invalid_list) > 0:
            flash('Invalid link(s): %s' %
                  ','.join(link for link in invalid_list), 'error')

        redirect(request.referer)

	def delete(self, proyecto_id ,id, **kw):
		"""
		@type  proyecto_id : Integer
		@param proyecto_id : Identificador del proyecto

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

		@type  kw : Hash
		@param kw : Keywords
		"""
		#se obtienen las relaciones del usuario sobre las fases del proyecto
		list = DBSession.query(UsuarioPermisoFase).\
				filter(UsuarioPermisoFase.usuario_id == id).\
				filter(Fase.proyecto == proyecto_id).\
				filter(UsuarioPermisoFase.fase_id == Fase.id_fase)
		#Se eliminan las relaciones del usuario con las fases
		for element in list :
			DBSession.delete(element)
		#Se obtienen los roles del usuario en el proyecto
		list = DBSession.query(RolUsuario).\
				  filter(RolUsuario.usuario_id == id).\
				  filter(RolUsuario.rol_id == RolPermisoProyecto.rol_id).\
				  filter(RolPermisoProyecto.proyecto_id == proyecto_id)
		#Se eliminan los roles del usuario sobre el proyecto
		for element in list :
			DBSession.delete(element)

		flash("El usuario '"+ str(id) +"' ha sido desvinculado del proyecto.")
		redirect("/miproyecto/ver/"+str(proyecto_id))

    def put(self, id_tipo_item, nombre_tipo_item, codigo_tipo_item, descripcion, campo, valor, **kw):

        if id_tipo_item is not None:
            id_tipo_item = int(id_tipo_item)

        tipo_item = Tipo_Item.get_tipo_item_by_id(id_tipo_item)
        campos2 = Tipo_Campos.get_campos_by_tipo_item(tipo_item.id_tipo_item)

        for cam in campos2:
            Tipo_Campos.borrar_by_id(cam.id_tipo_campos)
            DBSession.flush()

        tipo_item.nombre_tipo_item = nombre_tipo_item
        tipo_item.descripcion = descripcion
        tipo_item.codigo_tipo_item = codigo_tipo_item

        if campo is not None:
            if not isinstance(campo, list):
                campo = [campo]

        if valor is not None:
            if not isinstance(valor, list):
                valor = [valor]

        indice = 0

        for c in campo:
            if len(c) > 0:
                camp = Tipo_Campos(id_tipo_item=id_tipo_item, nombre_campo=c, valor_campo=valor[indice])
                DBSession.add(camp)
            indice += 1

        DBSession.flush()
        flash("Tipo de Item modificada!")
        redirect("/tipo_item/tipo_item")

 def refresh(self, **kw):
     allura.tasks.repo_tasks.refresh.post()
     if request.referer:
         flash('Repository is being refreshed')
         redirect(request.referer or '/')
     else:
         return '%r refresh queued.\n' % c.app.repo

    def saveUpdate(self, **kw):
        obj=getOr404(JCPItemInfo, kw["id"], "/%s/index"%self.url)
        combo_mapping_obj = JCPComboMappingInfo.get_by_main_code(obj.packaging_code)
        params = {"lastModifyBy": request.identity["user"],
                  "lastModifyTime": dt.now()
                  }
        combo_mapping_params = {"lastModifyBy": request.identity["user"],
                                "lastModifyTime": dt.now()
                                }
        combo_mapping_fields = ["hangtang_pkg_code",
                                "label_pkg_code",
                                ]
        combo_mapping_flag = False
        
        for f in self.formFields:
            if f in kw.keys() and f not in combo_mapping_fields:
                params[f]=kw[f]
            if f in kw.keys() and len(kw[f]) > 0 and f in combo_mapping_fields:
                combo_mapping_params[f] = kw[f]
                combo_mapping_flag = True

        if params['combo_item'] == 'False':
            params.pop('combo_packaging_code')
        
        for k in params: setattr(obj, k, params[k])
        if combo_mapping_flag == True:
            for key in combo_mapping_params: setattr(combo_mapping_obj[0], key, combo_mapping_params[key])
#       obj.set(**params)
        flash("Update the master successfully!")
        redirect("/%s/index"%self.url)

    def export(self, **kw):
        result_data=[]
        current=dt.now()
        dateStr=current.today().strftime("%Y%m%d")
        fileDir=os.path.join(os.path.abspath(os.path.curdir), "report_download", "%s"%dateStr)

        if not os.path.exists(fileDir): os.makedirs(fileDir)

        timeStr=current.time().strftime("%H%M%S")
        rn=random.randint(0, 10000)
        username=request.identity['repoze.who.userid']
        filename=os.path.join(fileDir, "%s_%s_%d.xls"%(username, timeStr, rn))
        templatePath=os.path.join(os.path.abspath(os.path.curdir), "report_download/TEMPLATE/JCP_SPECIAL_VALUE_TEMPLATE.xls")
        pe=JCPExcel(templatePath=templatePath, destinationPath=filename)

        try:
            results=self.searchMaster(kw)

            if results:
                for result in results:
                        result_data.append(self._format_value(result))

            pe.inputData(additionInfo=[], data=result_data)
            pe.outputData()

            return serveFile(unicode(filename))
        except:
            traceback.print_exc()
            if pe: pe.clearData()
            flash("Error occur in the Excel Exporting !")
            raise redirect("report")

 def delete(self, **kw):
     obj=getOr404(self.dbObj, kw["id"], "/%s/index"%self.url)
     obj.lastModifyBy=request.identity["user"]
     obj.lastModifyTime=dt.now()
     obj.status=1
     flash("Delete the master successfully!")
     redirect("/%s/index"%self.url)

 def post_delete(self, id):
     """Elimina una fase de la bd si el proyecto no está iniciado"""
     fase = Fase.por_id(id)
     proy = Proyecto.por_id(fase.id_proyecto)
     proy.eliminar_fase(id)
     flash("Fase eliminada")
     redirect("../")

    def post_miembro(self, idusuario, idrol, asmSelect0, fases):

        if idusuario is not None:
            idusuario = int(idusuario)      
        if idrol is not None:
            idrol = int(idrol)      

        if fases is not None:
            if not isinstance(fases, list):
                fases = [fases]
        fases = [DBSession.query(Fase).get(fase) for fase in fases]

        valor=int( Variables.get_valor_by_nombre("proyecto_actual"))
        equipo =  Equipo_Desarrollo(proyecto=valor, idusuario=idusuario, 
							        idrol=idrol, fases=fases)

#        usuario =  Usuario.get_user_by_id(idusuario)
#        rol = Rol.get_rol_by_id(idrol)
#        usuario.roles=[]
#        usuario.roles.append(rol)
        
        DBSession.add(equipo)
        DBSession.flush()

        flash("Miembro Agregado Agregado!")  
        redirect('/equipo/equipo')

    def put_seleccionar_tipo(self, id_fase, nombre_fase, id_tipo_fase, tipos_items,
                    descripcion, asmSelect0, nombre_tipo_fase,**kw):

        if id_fase is not None:
            id_fase=int(id_fase)

        if id_tipo_fase is not None:
            id_tipo_fase=int(id_tipo_fase)

        fase = Fase.get_fase_by_id(id_fase)

        if not isinstance(tipos_items, list):
			tipos_items = [tipos_items]
        tipos_items = [DBSession.query(Tipo_Item).get(tipo_item) for tipo_item
                                 in tipos_items]

        fase.nombre_fase = nombre_fase
        fase.id_tipo_fase=id_tipo_fase
        fase.estado = fase.estado
        fase.linea_base = fase.linea_base
        fase.descripcion = descripcion
        fase.tipos_items=tipos_items

        DBSession.flush()
        flash("Tipos Item agregados!")
        redirect('/proyecto/proyecto')

	def new(self, id_fase, method='', **kw):
		
		identity = request.environ.get('repoze.who.identity')
		if identity is not None:
			user = identity.get('user')
		idi = user.id_usuario
		
		rol_lider = DBSession.query(RolUsuario).filter(RolUsuario.id_usuario==idi).\
				filter(Rol.group_name=="lider").filter(Rol.id_rol == RolUsuario.id_rol).all()
		
		if(len(rol_lider)==0):
			crear = DBSession.query(Usperfa).filter(Usperfa.id_fase==id_fase).\
											filter(Permiso.permission_name=="crear_linea_base").\
											filter(Usperfa.id_permiso==Permiso.id_permiso).\
											filter(RolUsuario.id_usuario==idi).all()
			if len(crear)==0:
				flash("No posee los permisos para crear linea base",'error')
				redirect("/configuracion/linea_base/error")
			else:
				ItemsFieldSelect.id_fase = id_fase
				new_lineabase_form = NewLineaBaseForm(DBSession)#new_lineabase_form
				tmpl_context.widget = new_lineabase_form
		else:
			ItemsFieldSelect.id_fase = id_fase
			new_lineabase_form = NewLineaBaseForm(DBSession)#new_lineabase_form
			tmpl_context.widget = new_lineabase_form
		return dict(value=kw)

	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, **kw):
      ''' Update sound in DB
      '''
      id = int(kw['id'])
      s = DBSession.query(Sound).get(id)
      if kw.has_key('owner_id'):
         s.owner_id = kw['owner_id']
      s.comment = kw['comment']

      wav = kw['file']
      filetype = wav.type
      filedata = wav.file
      filename = '%s/%d_%s' % (dir_tmp, s.sound_id, wav.filename)
      # Temporarily save uploaded audio file
      out = open(filename, 'w')
      out.write(filedata.read())
      out.close()

      ret = process_file(filename, filetype, s.sound_id, filetype, s.name, s.language)

      if ret:
         flash(ret,'error')
         DBSession.delete(s)
         redirect('/moh/')

      flash(u'Son modifié')
      redirect('/moh/%d/edit' % id)

	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 download(self, id, **kw):
      ''' Download sound
      '''
      s = DBSession.query(Sound).get(id)
      dir = (dir_moh if s.type==0 else dir_sounds) % s.language
      fn = '%s/%s.' % (dir, re.sub(r'\W', '_', s.name))
      import os
      for form in ( 'wav', 'sln16', 'sln' ):
         try:
            st = os.stat(fn + form)
            f = open(fn + form)
            fn += form
            break
         except:
            log.debug(u'Sound file not found %s' % (fn+form))
            pass
      else:
         flash(u'Fichier sonore introuvable: %s' % fn, 'error')
         redirect('/moh/')

      rh = response.headers
      rh['Pragma'] = 'public' # for IE
      rh['Expires'] = '0'
      rh['Cache-Control'] = 'must-revalidate, post-check=0, pre-check=0' #for IE
      rh['Cache-Control'] = 'max-age=0' #for IE
      rh['Content-Type'] = 'audio/wav'
      rh['Content-Disposition'] = str( (u'attachment; filename="%s.%s"; size=%d;' % (
         s.name, form, st.st_size)).encode('utf-8') )
      rh['Content-Transfer-Encoding'] = 'binary'
      return f.read()

    def post_tipo_item(self, nombre_tipo_item, codigo_tipo_item, descripcion, campo, valor):
        tipo_item = Tipo_Item(
            nombre_tipo_item=nombre_tipo_item, codigo_tipo_item=codigo_tipo_item, descripcion=descripcion
        )

        DBSession.add(tipo_item)

        if campo is not None:
            if not isinstance(campo, list):
                campo = [campo]

        if valor is not None:
            if not isinstance(valor, list):
                valor = [valor]

        indice = 0
        id_tipo = Tipo_Item.get_ultimo_id()
        for c in campo:
            if len(c) > 0:
                camp = Tipo_Campos(id_tipo_item=id_tipo, nombre_campo=c, valor_campo=valor[indice])
                DBSession.add(camp)
            indice += 1

        flash("Tipo Item Agregado!")
        redirect("/tipo_item/tipo_item")

    def nuevo(self, id_fase, **kw):
        """Despliega el formulario para añadir una linea base a la fase"""
	fase=DBSession.query(Fase).get(id_fase)
	#Comprobación de si el estado de la fase se encuentra en Con Lineas Bases
	if fase.relacion_estado_fase.nombre_estado=='Con Lineas Bases':
		flash(_("Todos los items de esta fase ya se encuentran en una Linea Base Aprobada"), 'warning')
                redirect("/admin/linea_base/listado_linea_bases",id_proyecto=fase.id_proyecto, id_fase=id_fase)	    
	tipo_items=DBSession.query(TipoItem).filter_by(id_fase=id_fase)
	itemsDeFaseActual = []
	for tipo_item in tipo_items:
		itemsTipoItem = DBSession.query(Item).filter_by(id_tipo_item=tipo_item.id_tipo_item).filter_by(vivo=True)
		for itemTipoItem in itemsTipoItem:
			itemsDeFaseActual.append(itemTipoItem)
	contador_items_en_fase_actual = 0
	for item in itemsDeFaseActual:
		contador_items_en_fase_actual = contador_items_en_fase_actual + 1
	#Comprobación de si existen items cargados para la fase actual
	if contador_items_en_fase_actual == 0:
		flash(_("Aun no existen items cargados para esta fase"), 'warning')
                redirect("/admin/linea_base/listado_linea_bases",id_proyecto=fase.id_proyecto, id_fase=id_fase)		
        kw['id_estado']= 'Desarrollo'
        kw['id_fase']= id_fase
	kw['version']= '1'
	tmpl_context.form = crear_linea_base_form
        return dict(nombre_modelo='LineaBase', id_proyecto=fase.id_proyecto, id_fase=id_fase, page='nuevo', value=kw)