Example #1
0
 def export(self, **kw):
     try:
         current = dt.now()
         dateStr = current.strftime("%Y%m%d")
         fileDir = os.path.join(config.get("public_dir"), "report", 'ci', dateStr)
         if not os.path.exists(fileDir):
             os.makedirs(fileDir)
         templatePath = os.path.join(config.get("public_dir"), 'TEMPLATE', "CI_TEMPLATE.xlsx")
         tempFileName = os.path.join(fileDir, "tmp_%s.xlsx" % current.strftime("%Y%m%d%H%M%S"))
         realFileName = os.path.join(fileDir, "inventory_report_%s.xlsx" % current.strftime("%Y%m%d%H%M%S"))
         shutil.copy(templatePath, tempFileName)
         report_xls = InventoryExcel(templatePath=tempFileName, destinationPath=realFileName)
         data = []
         if kw:
             data = self._query_ci_result(kw)
         report_xls.inputData(data=data)
         report_xls.outputData()
         try:
             os.remove(tempFileName)
         except:
             pass
         return serveFile(unicode(realFileName))
     except:
         traceback.print_exc()
         flash("Export Fail.")
         redirect("/cireport/index")
Example #2
0
 def login(self, came_from=url('/')):
     """Start the user login."""
     login_counter = request.environ['repoze.who.logins']
     if login_counter > 0:
         flash(_('Wrong credentials'), 'warning')
     return dict(page='login', login_counter=str(login_counter),
                 came_from=came_from)
Example #3
0
 def post_logout(self, came_from=lurl('/')):
     """
     Redirect the user to the initially requested page on logout and say
     goodbye as well.
     """
     flash(_('Successfully logged out. We hope to see you soon!'))
     redirect(came_from)
Example #4
0
	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)
Example #5
0
 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/')
Example #6
0
    def post_delete(self, languageid):
        """Delete a Language"""
        language = DBSession.query(Language).get(languageid.decode())

        DBSession.delete(language)
        flash('%s %s' % (_('Deleted Language:'), language.id), 'ok')
        return dict(redirect_to=url('/admin/language/'))
Example #7
0
    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')
Example #8
0
	def delete(self, id_fase ,id, show=True, **kw):
		"""
		@type  id_fase : Integer
		@param id_fase : Identificador del Rol

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

		@type  show : Boolean
		@param show : Indica si se despelgara el mensaje al culminar la operacion.

		@type  kw : Hash
		@param kw : Keywords
		"""
		fase = fase_util.get_current()
		list = DBSession.query(UsuarioPermisoFase).\
				filter(UsuarioPermisoFase.usuario_id == id).\
				filter(UsuarioPermisoFase.fase_id == id_fase)

		for element in list :
			DBSession.delete(element)
		"""
		Si es false no muestra el mensaje de sobre la operacion, esto es debido
		que este metodo es reutilizado a la hora de eliminar a un usuario del
		proyecto
		"""
		if show :
			flash("El usuario '"+ str(id) +"' ha sido desvinculado de la fase.")
			redirect("/miproyecto/fase/get_all/"+ str(id_fase))
Example #9
0
	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))
Example #10
0
 def set_options(self, show_discussion=False, allow_email_posting=False):
     self.app.config.options[
         'show_discussion'] = show_discussion and True or False
     self.app.config.options[
         'AllowEmailPosting'] = allow_email_posting and True or False
     flash('Blog options updated')
     redirect(request.referer)
Example #11
0
    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)
Example #12
0
    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")
Example #13
0
 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
Example #14
0
File: rol.py Project: mbaez/SAP
	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")
Example #15
0
    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")
Example #16
0
 def update(self, card=None, **kw):
     permissions = self._index_permissions()
     old_permissions = dict(permissions)
     for args in card:
         perm = args['id']
         new_group_ids = args.get('new', [])
         group_ids = args.get('value', [])
         if isinstance(new_group_ids, basestring):
             new_group_ids = [ new_group_ids ]
         if isinstance(group_ids, basestring):
             group_ids = [ group_ids ]
         # make sure the admin group has the admin permission
         if perm == 'admin':
             if c.project.is_root:
                 pid = c.project._id
             else:
                 pid = c.project.parent_id
             admin_group_id = str(M.ProjectRole.query.get(project_id=pid, name='Admin')._id)
             if admin_group_id not in group_ids + new_group_ids:
                 flash('You cannot remove the admin group from the admin permission.','warning')
                 group_ids.append(admin_group_id)
         permissions[perm] = []
         role_ids = map(ObjectId, group_ids + new_group_ids)
         permissions[perm] = role_ids
     c.project.acl = []
     for perm, role_ids in permissions.iteritems():
         role_names = lambda ids: ','.join(sorted(
                 pr.name for pr in M.ProjectRole.query.find(dict(_id={'$in':ids}))))
         old_role_ids = old_permissions.get(perm, [])
         if old_role_ids != role_ids:
             M.AuditLog.log('updated "%s" permissions: "%s" => "%s"',
                            perm,role_names(old_role_ids), role_names(role_ids))
         c.project.acl += [M.ACE.allow(rid, perm) for rid in role_ids]
     g.post_event('project_updated')
     redirect('.')
Example #17
0
File: rol.py Project: mbaez/SAP
	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")
Example #18
0
 def set_home(self, new_home):
     self.app.root_page_name = new_home
     self.app.upsert_root(new_home)
     flash('Home updated')
     mount_base = c.project.url()+self.app.config.options.mount_point+'/'
     url = h.really_unicode(mount_base).encode('utf-8') + h.really_unicode(new_home).encode('utf-8')+'/'
     redirect(url)
Example #19
0
def check_access():
   '''Check access rights / group: admin=full access, boss=users from same department, user.
   Returns SA Query object for selected CDRs
   '''

   if in_any_group('admin', 'APPELS'):
      cdrs = DBSession.query(CDR)

   elif in_group('CDS'):
      # Find list of phones from the user's list of phones
      # user_phones -> departments -> phones
      phones = []
      for p in request.identity['user'].phone:
         log.info('CDS phone %s -> department %s' % (p, p.department))
      for d in [d.department for d in request.identity['user'].phone]:
         log.info('CDS department <%s>' % (d))
         for p in d.phones:
            phones.append(p)
      src = [prefix_src + p.exten for p in phones]
      dst = [p.exten for p in phones]
      cdrs = DBSession.query(CDR).filter( (CDR.src.in_(src)) | (CDR.dst.in_(dst)) )
      log.info('CDS phone <%s> -> source <%s>, destination <%s>' % (
         request.identity['user'].phone, src, dst))


   elif in_group('utilisateurs'):
      src = [prefix_src + p.exten for p in request.identity['user'].phone]
      dst = [p.exten for p in request.identity['user'].phone]
      cdrs = DBSession.query(CDR).filter( (CDR.src.in_(src)) | (CDR.dst.in_(dst)) )

   else:
      flash(u'Accès interdit')
      redirect('/')

   return cdrs
    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)
    def listadoItemsParaAsignaraLineaBase(self, id_proyecto, id_fase, id_linea_base, page=1):
        """Metodo para listar todos los items a asignar a la linea base"""
	lineabase=DBSession.query(LineaBase).get(id_linea_base)
        if lineabase.estado=='Aprobado':
		flash(_("La Linea Base ya se encuentra aprobada"), 'warning')
                redirect("/admin/linea_base/listado_linea_bases",id_proyecto=id_proyecto, id_fase=id_fase)
	linea_bases=DBSession.query(LineaBase).filter_by(id_fase=id_fase)
	itemsenLineaBase = []
	for linea_base in linea_bases:
		itemsLineaBase = linea_base.items
		for itemLineaBase in itemsLineaBase:
			itemsenLineaBase.append(itemLineaBase)
	#items Contiene todos los items que se encuentran en la fase actual
	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).filter_by(estado='Aprobado').order_by(Item.id_item)
		for itemTipoItem in itemsTipoItem:
			itemsDeFaseActual.append(itemTipoItem)
	items=itemsDeFaseActual
        if itemsenLineaBase != None: 
	   for item in itemsenLineaBase:
               if items.count(item) >= 1:
                  items.remove(item)
        currentPage = paginate.Page(items, page)
        return dict(items=currentPage.items, page='listadoItemsParaAsignaraLineaBase', id_proyecto=id_proyecto, 
                    id_fase=id_fase, id_linea_base=id_linea_base, currentPage=currentPage)
Example #22
0
   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)
Example #23
0
    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)
Example #24
0
 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)
Example #25
0
 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("../")
Example #26
0
    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')
Example #27
0
    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')
Example #28
0
    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")
Example #29
0
	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)
Example #30
0
   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()
Example #31
0
	def aprobar(self, id, **kw):
		"""Metodo invocado para aprobar un item especificado"""
		identity = request.environ.get('repoze.who.identity')
		if identity is not None:
			user = identity.get('user')
		idi = user.id_usuario
		
		id_tipo = DBSession.query(Item.id_tipoitem).filter(Item.id_item==id).one()
		id_fase = DBSession.query(TipoItem.id_fase).filter(TipoItem.id_tipoitem==id_tipo).one()
		
		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):
			aprob = DBSession.query(Usperfa).filter(Usperfa.id_fase==id_fase).\
											filter(Permiso.permission_name=="aprobar_item").\
											filter(Usperfa.id_permiso==Permiso.id_permiso).\
											filter(RolUsuario.id_usuario==idi).all()
			if len(aprob)==0:
				flash("No posee permiso para aprobar item",'error')
				redirect("/desarrollo/item/error")
			else:
				item = DBSession.query(Item).get(id)
				item.estado = "aprobado"
				identity = request.environ.get('repoze.who.identity')
				if identity is not None:
					user = identity.get('user')
				idi = user.id_usuario
				ahora = time.localtime()
				anho = str(ahora.tm_year)
				mes = str(ahora.tm_mon)
				dia = str(ahora.tm_mday)
				hora = str(ahora.tm_hour)
				min = str(ahora.tm_min)
				seg = str(ahora.tm_sec)
				historial = Historial()
				historial.cod_recurso = item.cod_item
				historial.tipo_recurso = "Item"
				historial.nombre_recurso = item.nombre_item
				historial.operacion = "Aprobacion"
				historial.fecha_operacion = anho+'-'+mes+'-'+dia
				historial.hora = hora+':'+min+':'+seg
				historial.nombre_usuario = user.user_name
				DBSession.add(historial)
				flash("Item aprobado")
				redirect('/desarrollo/item/list/'+str(self.id_fase))
		#~ else:
			#~ item = DBSession.query(Item).get(id)
			#~ item.estado = "aprobado"
		else:#*******************************************************************************************desde aca
			item = DBSession.query(Item).get(id)
			item.estado = "aprobado"
			iditem = item.id_item
			
			if (item.id_lb!=None):
				"""Si todos los items de la linea base, que fueron modificados, 
				se aprueban, la linea base se cierra automaticamente"""
				lb = DBSession.query(ItemLineaBase.id_lb).filter(ItemLineaBase.id_item==iditem).one()
				print ("0000000000000000000000000000000000000000000000000000000 linea base del item en put es: %s") % (lb)
				list_items = []
				apro = 0
				list_items = DBSession.query(Item).filter(Item.id_lb==lb).all()
				for k in list_items:
					if (k.estado == "aprobado"):
						apro = apro + 1
				if(len(list_items)==apro):
					li_b = DBSession.query(LineaBase).filter(LineaBase.id_lb==lb).all()
					for m in li_b:
						m.estado = "cerrado"
						DBSession.merge(m)
					#**************************************************************************************hasta aca
			
			identity = request.environ.get('repoze.who.identity')
			if identity is not None:
				user = identity.get('user')
			idi = user.id_usuario
			ahora = time.localtime()
			anho = str(ahora.tm_year)
			mes = str(ahora.tm_mon)
			dia = str(ahora.tm_mday)
			hora = str(ahora.tm_hour)
			min = str(ahora.tm_min)
			seg = str(ahora.tm_sec)
			historial = Historial()
			historial.cod_recurso = item.cod_item
			historial.tipo_recurso = "Item"
			historial.nombre_recurso = item.nombre_item
			historial.operacion = "Aprobacion"
			historial.fecha_operacion = anho+'-'+mes+'-'+dia
			historial.hora = hora+':'+min+':'+seg
			historial.nombre_usuario = user.user_name
			DBSession.add(historial)
			flash("Item aprobado")
			redirect('/desarrollo/item/list/'+str(self.id_fase))
Example #32
0
class PreferencesController(BaseController):

    @with_trailing_slash
    @expose('jinja:allura:templates/user_preferences.html')
    def index(self, **kw):
        require_authenticated()
        c.form = F.subscription_form
        c.revoke_access = F.oauth_revocation_form
        subscriptions = []
        mailboxes = M.Mailbox.query.find(dict(user_id=c.user._id, is_flash=False))
        mailboxes = list(mailboxes.ming_cursor)
        project_collection = M.Project.query.mapper.collection
        app_collection = M.AppConfig.query.mapper.collection
        projects = dict(
            (p._id, p) for p in project_collection.m.find(dict(
                    _id={'$in': [mb.project_id for mb in mailboxes ]})))
        app_index = dict(
            (ac._id, ac) for ac in app_collection.m.find(dict(
                    _id={'$in': [mb.app_config_id for mb in mailboxes]})))

        for mb in mailboxes:
            project = projects.get(mb.project_id, None)
            app_config = app_index.get(mb.app_config_id, None)
            if project is None:
                mb.m.delete()
                continue
            if app_config is None:
                continue
            title = mb.artifact_title
            if mb.artifact_url:
                title = '<a href="%s">%s</a>' % (mb.artifact_url,title)
            subscriptions.append(dict(
                    _id=mb._id,
                    project_name=project.name,
                    mount_point=app_config.options['mount_point'],
                    artifact_title=title,
                    topic=mb.topic,
                    type=mb.type,
                    frequency=mb.frequency.unit,
                    artifact=mb.artifact_index_id))
        api_token = M.ApiToken.query.get(user_id=c.user._id)
        provider = plugin.AuthenticationProvider.get(request)
        menu = provider.account_navigation()
        return dict(
            subscriptions=subscriptions,
            api_token=api_token,
            authorized_applications=M.OAuthAccessToken.for_user(c.user),
            menu=menu)

    @h.vardec
    @expose()
    @require_post()
    def update(self,
               display_name=None,
               addr=None,
               new_addr=None,
               primary_addr=None,
               oid=None,
               new_oid=None,
               preferences=None,
               **kw):
        require_authenticated()
        if config.get('auth.method', 'local') == 'local':
            if display_name is None:
                flash("Display Name cannot be empty.",'error')
                redirect('.')
            c.user.set_pref('display_name', display_name)
            for i, (old_a, data) in enumerate(zip(c.user.email_addresses, addr or [])):
                obj = c.user.address_object(old_a)
                if data.get('delete') or not obj:
                    del c.user.email_addresses[i]
                    if obj: obj.delete()
            c.user.set_pref('email_address', primary_addr)
            if new_addr.get('claim'):
                if M.EmailAddress.query.get(_id=new_addr['addr'], confirmed=True):
                    flash('Email address already claimed', 'error')
                else:
                    c.user.email_addresses.append(new_addr['addr'])
                    em = M.EmailAddress.upsert(new_addr['addr'])
                    em.claimed_by_user_id=c.user._id
                    em.send_verification_link()
            for i, (old_oid, data) in enumerate(zip(c.user.open_ids, oid or [])):
                obj = c.user.openid_object(old_oid)
                if data.get('delete') or not obj:
                    del c.user.open_ids[i]
                    if obj: obj.delete()
            for k,v in preferences.iteritems():
                if k == 'results_per_page':
                    v = int(v)
                c.user.set_pref(k, v)
        if 'email_format' in preferences:
            c.user.set_pref('email_format', preferences['email_format'])
        redirect('.')

    @h.vardec
    @expose()
    @require_post()
    @validate(F.subscription_form, error_handler=index)
    def update_subscriptions(self, subscriptions=None, **kw):
        for s in subscriptions:
            if s['unsubscribe']:
                s['_id'].delete()
        redirect(request.referer)

    @expose()
    @require_post()
    def gen_api_token(self):
        tok = M.ApiToken.query.get(user_id=c.user._id)
        if tok is None:
            tok = M.ApiToken(user_id=c.user._id)
        else:
            tok.secret_key = h.cryptographic_nonce()
        redirect(request.referer)

    @expose()
    @require_post()
    def del_api_token(self):
        tok = M.ApiToken.query.get(user_id=c.user._id)
        if tok is None: return
        tok.delete()
        redirect(request.referer)

    @expose()
    @require_post()
    def revoke_oauth(self, _id=None):
        tok = M.OAuthAccessToken.query.get(_id=bson.ObjectId(_id))
        if tok is None:
            flash('Invalid app ID', 'error')
            redirect('.')
        if tok.user_id != c.user._id:
            flash('Invalid app ID', 'error')
            redirect('.')
        tok.delete()
        flash('Application access revoked')
        redirect('.')

    @expose()
    @require_post()
    @validate(V.NullValidator(), error_handler=index)
    def change_password(self, **kw):
        kw = g.theme.password_change_form.to_python(kw, None)
        ap = plugin.AuthenticationProvider.get(request)
        try:
            ap.set_password(c.user, kw['oldpw'], kw['pw'])
        except wexc.HTTPUnauthorized:
            flash('Incorrect password', 'error')
            redirect('.')
        flash('Password changed')
        redirect('.')

    @expose()
    @require_post()
    def upload_sshkey(self, key=None):
        ap = plugin.AuthenticationProvider.get(request)
        try:
            ap.upload_sshkey(c.user.username, key)
        except AssertionError, ae:
            flash('Error uploading key: %s' % ae, 'error')
        flash('Key uploaded')
        redirect('.')
Example #33
0
 def claim_process_oid(self, **kw):
     oid_obj = process_oid(failure_redirect='claim_oid')
     if c.user:
         c.user.claim_openid(oid_obj._id)
         flash('Claimed %s' % oid_obj._id)
     redirect('/auth/prefs/')
Example #34
0
    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)
Example #35
0
    def remove(self, **kw):
        cat = M.TroveCategory.query.get(trove_cat_id=int(kw['categoryid']))
        if cat.trove_parent_id:
            parent = M.TroveCategory.query.get(
                trove_cat_id=cat.trove_parent_id)
            redirecturl = '/categories/%s' % parent.trove_cat_id
        else:
            redirecturl = '/categories'
        if len(cat.subcategories) > 0:
            m = "This category contains at least one sub-category, "
            m = m + "therefore it can't be removed."
            flash(m, "error")
            redirect(redirecturl)
            return

        if M.User.withskill(cat).count() > 0:
            m = "This category is used as a skill by at least a user, "
            m = m + "therefore it can't be removed."
            flash(m, "error")
            redirect(redirecturl)
            return

        if M.Project.query.get(trove_root_database=cat._id):
            m = "This category is used as a database by at least a project, "
            m = m + "therefore it can't be removed."
            flash(m, "error")
            redirect(redirecturl)
            return

        if M.Project.query.get(trove_developmentstatus=cat._id):
            m = "This category is used as development status by at least a "
            m = m + "project, therefore it can't be removed."
            flash(m, "error")
            redirect(redirecturl)
            return

        if M.Project.query.get(trove_audience=cat._id):
            m = "This category is used as intended audience by at least a "
            m = m + "project, therefore it can't be removed."
            flash(m, "error")
            redirect(redirecturl)
            return

        if M.Project.query.get(trove_license=cat._id):
            m = "This category is used as a license by at least a "
            m = m + "project, therefore it can't be removed."
            flash(m, "error")
            redirect(redirecturl)
            return

        if M.Project.query.get(trove_os=cat._id):
            m = "This category is used as operating system by at least a "
            m = m + "project, therefore it can't be removed."
            flash(m, "error")
            redirect(redirecturl)
            return

        if M.Project.query.get(trove_language=cat._id):
            m = "This category is used as programming language by at least a "
            m = m + "project, therefore it can't be removed."
            flash(m, "error")
            redirect(redirecturl)
            return

        if M.Project.query.get(trove_topic=cat._id):
            m = "This category is used as a topic by at least a "
            m = m + "project, therefore it can't be removed."
            flash(m, "error")
            redirect(redirecturl)
            return

        if M.Project.query.get(trove_natlanguage=cat._id):
            m = "This category is used as a natural language by at least a "
            m = m + "project, therefore it can't be removed."
            flash(m, "error")
            redirect(redirecturl)
            return

        if M.Project.query.get(trove_environment=cat._id):
            m = "This category is used as an environment by at least a "
            m = m + "project, therefore it can't be removed."
            flash(m, "error")
            redirect(redirecturl)
            return

        M.TroveCategory.delete(cat)

        flash('Category removed.')
        redirect(redirecturl)
Example #36
0
 def login(self, came_from=lurl('/')):
     """Start the user login."""
     login_counter = request.environ['repoze.who.logins']
     if login_counter > 0:
         flash(_('Wrong credentials.'), 'warning')
     return dict(page='login', login_counter=str(login_counter), came_from=came_from)
Example #37
0
	def post(self, id_fase, method='', **kw):
		"""Metodo invocado para persistir los datos del item creado en la BD"""
		del kw['sprox_id']
		funciones = Funciones()
		item = Item()
		item.id_tipoitem = kw['tipo_item']
		tipoitem = DBSession.query(TipoItem).filter(TipoItem.id_tipoitem==item.id_tipoitem).first()
		cod_tipoitem = tipoitem.cod_tipoitem
		item.cod_item = str(cod_tipoitem)+str(funciones.generador_codigo_item(cod_tipoitem))
		item.nombre_item = kw['nombre_item']
		item.descripcion = kw['descripcion']
		item.version = 1#kw['version']
		item.estado = "en desarrollo"
		item.complejidad = kw['complejidad']

		id_fa = id_fase

		item.id_tipoitem = kw['tipo_item']
		
		DBSession.add(item)
		DBSession.flush()
		#VERSIONADO_ITEM
		cod_tipoitem_versionado = DBSession.query(TipoItem.cod_tipoitem).filter(TipoItem.id_tipoitem==item.id_tipoitem).first()
		
		versionadoitem = VersionadoItem()
		versionadoitem.cod_item = item.cod_item
		versionadoitem.cod_tipoitem= cod_tipoitem_versionado
		versionadoitem.nombre_item = item.nombre_item
		versionadoitem.descripcion = item.descripcion
		versionadoitem.version = item.version
		versionadoitem.complejidad = item.complejidad
		
		DBSession.add(versionadoitem)
		DBSession.flush()
		print ("0000000000000000000000000000000000000000000000000000000000000000 VERSIONADO %s") % (versionadoitem.id_versionado)
		
		#se crean los detalles del item en base a los detalles del tipo
		detalles = DBSession.query(DetalleTipoItem.id_detalletipoitem).filter(DetalleTipoItem.id_tipoitem==kw['tipo_item']).all()
		
		for i in detalles:
			detalle = DBSession.query(DetalleTipoItem).get(i)
			atributo = DetalleItem()
			atributo.id_item = item.id_item
			atributo.tipo_dato = DBSession.query(DetalleTipoItem.tipo_dato).filter(DetalleTipoItem.id_detalletipoitem==i).first()
			atributo.id_detalletipoitem = i
			atributo.cod_detalleitem = funciones.generador_codigo(detalle.nombre_atributo)
			atributo.cod_detalletipoitem = DBSession.query(DetalleTipoItem.cod_detalletipoitem).filter(DetalleTipoItem.id_detalletipoitem==i).first()
			atributo.nombre_atributo = detalle.nombre_atributo
			atributo.valor = None
			#atributo.archivo = None
			DBSession.add(atributo)
			
			#DETALLE_VERSIONADO_ITEM
			detalleversionadoitem = DetalleVersionadoItem()
			detalleversionadoitem.id_versionado = versionadoitem.id_versionado
			detalleversionadoitem.cod_item = item.cod_item
			detalleversionadoitem.cod_detalleitem = atributo.cod_detalleitem
			detalleversionadoitem.cod_detalletipoitem = atributo.cod_detalletipoitem
			detalleversionadoitem.nombre_atributo = detalle.nombre_atributo
			detalleversionadoitem.tipo_dato = atributo.tipo_dato
			detalleversionadoitem.valor = None
			#detalleversionadoitem.archivo = atributo.archivo
			DBSession.add(detalleversionadoitem)
			
		
		identity = request.environ.get('repoze.who.identity')
		if identity is not None:
			user = identity.get('user')
		idi = user.id_usuario
		ahora = time.localtime()
		anho = str(ahora.tm_year)
		mes = str(ahora.tm_mon)
		dia = str(ahora.tm_mday)
		hora = str(ahora.tm_hour)
		min = str(ahora.tm_min)
		seg = str(ahora.tm_sec)
		historial = Historial()
		historial.cod_recurso = item.cod_item
		historial.tipo_recurso = "Item"
		historial.nombre_recurso = item.nombre_item
		historial.operacion = "Creacion"
		historial.fecha_operacion = anho+'-'+mes+'-'+dia
		historial.hora = hora+':'+min+':'+seg
		historial.nombre_usuario = user.user_name
		DBSession.add(historial)
		
		flash('Item creado')
		redirect('/desarrollo/item/list/'+str(id_fa))
Example #38
0
	def put(self, id='', **kw):
		"""Metodo invocado para persistir los datos modificados """
		del kw['sprox_id']
		item = DBSession.query(Item).get(id)
		id_tipo = DBSession.query(Item.id_tipoitem).filter(Item.id_item==id).one()
		id_fase = DBSession.query(TipoItem.id_fase).filter(TipoItem.id_tipoitem==id_tipo).all()

		for i in id_fase:
			fase = DBSession.query(Fase).get(i)
		print ("0000000000000000000000000000000000000000000000000000000 version del item en put es: %d") % (item.version)
		item.nombre_item = kw['nombre_item']
		item.descripcion = kw['descripcion']
		item.estado = "revision"
		#item.id_tipoitem = kw['tipo_item']
		item.version = item.version + 1
		item.complejidad = kw['complejidad']
		
		DBSession.merge(item)
		
		""" si el item se encuentra en una linea base, esta debe estar abierta... una vez abierta, debe pasar a estado 
			comprometido
		"""
		#relaciones del item modificado
		list_relaciones = DBSession.query(Relacion.id_relacion).filter(Relacion.id_item1==id).all()
		print ("wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww linea base del item en put es: %s") % (list_relaciones)
		for i in list_relaciones:
			iditem = DBSession.query(Relacion.id_item2).filter(Relacion.id_relacion==i).one()
			lb = DBSession.query(ItemLineaBase.id_lb).filter(ItemLineaBase.id_item==iditem).one()
			print ("0000000000000000000000000000000000000000000000000000000 linea base del item en put es: %d") % (lb)
			linea = DBSession.query(LineaBase).filter(LineaBase.id_lb==lb).all()
			for j in linea:
				j.estado = "comprometida"
				DBSession.merge(j)

					
		lb = DBSession.query(ItemLineaBase.id_lb).filter(ItemLineaBase.id_item==id).first()
		if lb is not None:
			print ("0000000000000000000000000000000000000000000000000000000 linea base del item en put es: %d") % (lb)
			linea = DBSession.query(LineaBase).filter(LineaBase.id_lb==lb).all()
			for i in linea:
				i.estado = "comprometida"
				DBSession.merge(i)
		#Aqui se Agrega el registro del item a la taba de versionado
		cod_tipoitem_versionado = DBSession.query(Item.id_tipoitem).filter(Item.id_item==id).first()
		
		versionadoitem = VersionadoItem()
		versionadoitem.cod_item = item.cod_item
		versionadoitem.cod_tipoitem= cod_tipoitem_versionado
		versionadoitem.nombre_item = item.nombre_item
		versionadoitem.descripcion = item.descripcion
		versionadoitem.version = item.version
		versionadoitem.complejidad = item.complejidad
		
		DBSession.add(versionadoitem)
		DBSession.flush()

		
		identity = request.environ.get('repoze.who.identity')
		if identity is not None:
			user = identity.get('user')
		idi = user.id_usuario
		ahora = time.localtime()
		anho = str(ahora.tm_year)
		mes = str(ahora.tm_mon)
		dia = str(ahora.tm_mday)
		hora = str(ahora.tm_hour)
		min = str(ahora.tm_min)
		seg = str(ahora.tm_sec)
		historial = Historial()
		historial.cod_recurso = item.cod_item
		historial.tipo_recurso = "Item"
		historial.nombre_recurso = item.nombre_item
		historial.operacion = "Modificacion"
		historial.fecha_operacion = anho+'-'+mes+'-'+dia
		historial.hora = hora+':'+min+':'+seg
		historial.nombre_usuario = user.user_name
		DBSession.add(historial)
		
		flash('Item modificado')
		redirect("/desarrollo/item/list/"+str(fase.id_fase))
Example #39
0
 def index(self):
     flash(_("Hello World!"))
     return dict(page='index', idproject=None)
Example #40
0
	def post_delete(self, id, **kw):
		"""Metodo invocado para eliminar un item especificado"""
		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):
			eliminar = DBSession.query(Usperfa).filter(Usperfa.id_fase==id_fase).\
											filter(Permiso.permission_name=="eliminar_item").\
											filter(Usperfa.id_permiso==Permiso.id_permiso).\
											filter(RolUsuario.id_usuario==idi).all()
			if len(list)==0:
				flash("No posee los permisos para eliminar los items de la fase",'error')
				redirect("/desarrollo/item/error")
			else:
				list_relaciones = DBSession.query(Relacion.id_relacion).filter(Relacion.id_item1==id).all()
				for i in list_relaciones:
					DBSession.delete(DBSession.query(Relacion).get(i))
				
				item = DBSession.query(Item).get(int(id))
				identity = request.environ.get('repoze.who.identity')
				if identity is not None:
					user = identity.get('user')
				idi = user.id_usuario
				ahora = time.localtime()
				anho = str(ahora.tm_year)
				mes = str(ahora.tm_mon)
				dia = str(ahora.tm_mday)
				hora = str(ahora.tm_hour)
				min = str(ahora.tm_min)
				seg = str(ahora.tm_sec)
				historial = Historial()
				historial.cod_recurso = item.cod_item
				historial.tipo_recurso = "Item"
				historial.nombre_recurso = item.nombre_item
				historial.operacion = "Eliminacion"
				historial.fecha_operacion = anho+'-'+mes+'-'+dia
				historial.hora = hora+':'+min+':'+seg
				historial.nombre_usuario = user.user_name
				DBSession.add(historial)
				DBSession.delete(DBSession.query(Item).get(id))
				redirect('/desarrollo/item/list/'+str(self.id_fase))
		else:
			list_relaciones = DBSession.query(Relacion.id_relacion).filter(Relacion.id_item1==id).all()
			for i in list_relaciones:
				DBSession.delete(DBSession.query(Relacion).get(i))
				
			item = DBSession.query(Item).get(int(id))
			identity = request.environ.get('repoze.who.identity')
			if identity is not None:
				user = identity.get('user')
			idi = user.id_usuario
			ahora = time.localtime()
			anho = str(ahora.tm_year)
			mes = str(ahora.tm_mon)
			dia = str(ahora.tm_mday)
			hora = str(ahora.tm_hour)
			min = str(ahora.tm_min)
			seg = str(ahora.tm_sec)
			historial = Historial()
			historial.cod_recurso = item.cod_item
			historial.tipo_recurso = "Item"
			historial.nombre_recurso = item.nombre_item
			historial.operacion = "Eliminacion"
			historial.fecha_operacion = anho+'-'+mes+'-'+dia
			historial.hora = hora+':'+min+':'+seg
			historial.nombre_usuario = user.user_name
			DBSession.add(historial)
				
				
			DBSession.delete(DBSession.query(Item).get(id))
			redirect('/desarrollo/item/list/'+str(self.id_fase))
Example #41
0
 def post_logout(self, came_from=url('/')):
     """Redirect the user to the root page on logout and say
     goodbye as well."""
     flash(_('We hope to see you soon!'))
     redirect('/')
Example #42
0
	def edit(self, id,**kw):
		"""Metodo para editar un item"""
		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):
		
			id_tipo = DBSession.query(Item.id_tipoitem).filter(Item.id_item==id).one()
			id_fase = DBSession.query(TipoItem.id_fase).filter(TipoItem.id_tipoitem==id_tipo).one()
			
			editar = DBSession.query(Usperfa).filter(Usperfa.id_fase==id_fase).\
											filter(Permiso.permission_name=="editar_item").\
											filter(Usperfa.id_permiso==Permiso.id_permiso).\
											filter(RolUsuario.id_usuario==idi).all()
			if len(editar)==0:
				flash("No posee los permisos para editar los items de la fase",'error')
				redirect("/desarrollo/item/error")
			else:#********************************************************************************************desde aca
				item = DBSession.query(Item).get(id)
				ide_lb = DBSession.query(ItemLineaBase.id_lb).filter(ItemLineaBase.id_item==id).first()
				print ("0000000000000000000000000000000000000000000000000000000 %d") % (ide_lb)
				if ide_lb is not None:
					estado_lb = DBSession.query(LineaBase.estado).filter(LineaBase.id_lb==ide_lb).one()
					if (estado_lb != "cerrado"):
						id_tipo = DBSession.query(Item.id_tipoitem).filter(Item.id_item==id).one()
						id_fase = DBSession.query(TipoItem.id_fase).filter(TipoItem.id_tipoitem==id_tipo).one()
						#edit_item_form.tipo_item.id_fase = id_fase
						tmpl_context.widget = edit_item_form
						kw['id_item'] = item.id_item
						value = edit_item_filler.get_value(kw)
					else:
						if (estado_lb == "cerrado"):
							ide_lb = DBSession.query(Item.id_lb).filter(Item.id_item==id).one()
							id_fa = DBSession.query(LineaBase.id_fase).filter(LineaBase.id_lb==ide_lb).one() ######
							flash("El item pertenece a una Linea Base cerrada",'error')
							redirect("/desarrollo/item/error")
						#~ redirect('/desarrollo/item/list/'+str(id_fa))
				else:
					item = DBSession.query(Item).get(id)
					id_tipo = DBSession.query(Item.id_tipoitem).filter(Item.id_item==id).one()
					id_fase = DBSession.query(TipoItem.id_fase).filter(TipoItem.id_tipoitem==id_tipo).one()
					#edit_item_form.tipo_item.id_fase = id_fase
					tmpl_context.widget = edit_item_form
					kw['id_item'] = item.id_item
					value = edit_item_filler.get_value(kw)
		else:
			item = DBSession.query(Item).get(id) # if para controlar...
			ide_lb = DBSession.query(ItemLineaBase.id_lb).filter(ItemLineaBase.id_item==id).first()
			if ide_lb is not None:
				id_fase = DBSession.query(LineaBase.id_fase).filter(LineaBase.id_lb==ide_lb).one()
				estado_lb = DBSession.query(LineaBase.estado).filter(LineaBase.id_lb==ide_lb).one()
				if (estado_lb != "cerrado"):
					id_tipo = DBSession.query(Item.id_tipoitem).filter(Item.id_item==id).one() ####
					id_fase = DBSession.query(TipoItem.id_fase).filter(TipoItem.id_tipoitem==id_tipo).one() ####
					#edit_item_form.tipo_item.id_fase = id_fase
					tmpl_context.widget = edit_item_form
					kw['id_item'] = item.id_item
					value = edit_item_filler.get_value(kw)
				else:
					 if (estado_lb == "cerrado"):
						item = DBSession.query(Item).get(id) ###
						ide_lb = DBSession.query(ItemLineaBase.id_lb).filter(ItemLineaBase.id_item==id).one() ###
						id_fa = DBSession.query(LineaBase.id_fase).filter(LineaBase.id_lb==ide_lb).one() ###
						flash("El item pertenece a una Linea Base cerrada",'error')
						redirect("/desarrollo/item/error")
			else:
				item = DBSession.query(Item).get(id)
				id_tipo = DBSession.query(Item.id_tipoitem).filter(Item.id_item==id).one()
				id_fase = DBSession.query(TipoItem.id_fase).filter(TipoItem.id_tipoitem==id_tipo).one()
				#edit_item_form.tipo_item.id_fase = id_fase
				tmpl_context.widget = edit_item_form
				kw['id_item'] = item.id_item
				value = edit_item_filler.get_value(kw)
		#~ else:
			#~ item = DBSession.query(Item).get(id)
			#~ id_tipo = DBSession.query(Item.id_tipoitem).filter(Item.id_item==id).one()
			#~ id_fase = DBSession.query(TipoItem.id_fase).filter(TipoItem.id_tipoitem==id_tipo).one()
			#~ #edit_item_form.tipo_item.id_fase = id_fase
			#~ tmpl_context.widget = edit_item_form
			#~ kw['id_item'] = item.id_item
			#~ value = edit_item_filler.get_value(kw)
		return dict(id_fase=id_fase, value=value)
Example #43
0
 def flag_as_spam(self, **kw):
     require_access(self.thread, 'moderate')
     self.thread.spam()
     flash('Thread flagged as spam.')
     redirect(self.discussion.url())
Example #44
0
 def set_language(self, languageid, came_from=url('/')):
     """Set language cookie"""
     language = DBSession.query(Language).get(languageid.decode())
     response.set_cookie('lang', language.id)
     flash('%s %s' % (_('Preferred language set to:'), language.name))
     redirect(came_from)
Example #45
0
 def index(self):
     """Let the user know that's visiting a protected controller."""
     flash(_("Secure Controller here"))
     return dict(page='index')
Example #46
0
 def unset_language(self, came_from=url('/')):
     """Delete language cookie"""
     response.delete_cookie('lang')
     flash(_('No preferred language'))
     redirect(came_from)
Example #47
0
    def post(self,
             label,
             parent_id=None,
             can_contain_folders=False,
             can_contain_threads=False,
             can_contain_files=False,
             can_contain_pages=False):
        # TODO - SECURE THIS
        workspace = tmpl_context.workspace

        api = ContentApi(tmpl_context.current_user)

        redirect_url_tmpl = '/workspaces/{}/folders/{}'
        redirect_url = ''

        try:
            parent = None
            if parent_id:
                parent = api.get_one(int(parent_id), ContentType.Folder,
                                     workspace)

            with DBSession.no_autoflush:
                folder = api.create(ContentType.Folder, workspace, parent,
                                    label)

                subcontent = dict(
                    folder=True if can_contain_folders == 'on' else False,
                    thread=True if can_contain_threads == 'on' else False,
                    file=True if can_contain_files == 'on' else False,
                    page=True if can_contain_pages == 'on' else False)
                api.set_allowed_content(folder, subcontent)

                if not self._path_validation.validate_new_content(folder):
                    return render_invalid_integrity_chosen_path(
                        folder.get_label(), )

            api.save(folder)

            tg.flash(_('Folder created'), CST.STATUS_OK)
            redirect_url = redirect_url_tmpl.format(tmpl_context.workspace_id,
                                                    folder.content_id)
        except Exception as e:
            logger.error(
                self,
                'An unexpected exception has been catched. Look at the traceback below.'
            )
            traceback.print_exc()

            tb = sys.exc_info()[2]
            tg.flash(
                _('Folder not created: {}').format(e.with_traceback(tb)),
                CST.STATUS_ERROR)
            if parent_id:
                redirect_url = redirect_url_tmpl.format(
                    tmpl_context.workspace_id, parent_id)
            else:
                redirect_url = '/workspaces/{}'.format(
                    tmpl_context.workspace_id)

        ####
        #
        # INFO - D.A. - 2014-10-22 - Do not put redirect in a
        # try/except block as redirect is using exceptions!
        #
        tg.redirect(tg.url(redirect_url))
Example #48
0
 def save(self, name, events_type):
     new_calendar = create_calendar(name=name, events_type=events_type)
     model.DBSession.flush()
     flash(_('Calendar successfully added'))
     return plug_redirect('calendarevents',
                          '/calendar/%d' % new_calendar.uid)
Example #49
0
    def put(self, item_id, file_data=None, comment=None, label=None):
        # TODO - SECURE THIS
        workspace = tmpl_context.workspace

        try:
            api = ContentApi(tmpl_context.current_user)
            item = api.get_one(int(item_id), self._item_type, workspace)
            label_changed = False
            if label is not None and label != item.label:
                label_changed = True

            if label is None:
                label = ''

            # TODO - D.A. - 2015-03-19
            # refactor this method in order to make code easier to understand

            with new_revision(item):

                if (comment and label) or (not comment and label_changed):
                    updated_item = api.update_content(
                        item, label if label else item.label,
                        comment if comment else '')

                    # Display error page to user if chosen label is in conflict
                    if not self._path_validation.validate_new_content(
                            updated_item, ):
                        return render_invalid_integrity_chosen_path(
                            updated_item.get_label_as_file(), )

                    api.save(updated_item, ActionDescription.EDITION)

                    # This case is the default "file title and description update"
                    # In this case the file itself is not revisionned

                else:
                    # So, now we may have a comment and/or a file revision
                    if comment and '' == label:
                        comment_item = api.create_comment(workspace,
                                                          item,
                                                          comment,
                                                          do_save=False)

                        if not isinstance(file_data, FieldStorage):
                            api.save(comment_item, ActionDescription.COMMENT)
                        else:
                            # The notification is only sent
                            # if the file is NOT updated
                            #
                            #  If the file is also updated,
                            #  then a 'file revision' notification will be sent.
                            api.save(comment_item,
                                     ActionDescription.COMMENT,
                                     do_notify=False)

                    if isinstance(file_data, FieldStorage):
                        api.update_file_data(item, file_data.filename,
                                             file_data.type,
                                             file_data.file.read())

                        # Display error page to user if chosen label is in
                        # conflict
                        if not self._path_validation.validate_new_content(
                                item, ):
                            return render_invalid_integrity_chosen_path(
                                item.get_label_as_file(), )

                        api.save(item, ActionDescription.REVISION)

            msg = _('{} updated').format(self._item_type_label)
            tg.flash(msg, CST.STATUS_OK)
            tg.redirect(
                self._std_url.format(tmpl_context.workspace_id,
                                     tmpl_context.folder_id, item.content_id))

        except ValueError as e:
            msg = _('{} not updated - error: {}').format(
                self._item_type_label, str(e))
            tg.flash(msg, CST.STATUS_ERROR)
            tg.redirect(
                self._err_url.format(tmpl_context.workspace_id,
                                     tmpl_context.folder_id, item_id))
Example #50
0
 def reclone_repo(self,
                  prefix=None,
                  shortname=None,
                  mount_point=None,
                  **data):
     if request.method == 'POST':
         if c.form_errors:
             error_msg = 'Error: '
             for msg in list(c.form_errors):
                 names = {
                     'prefix': 'Neighborhood prefix',
                     'shortname': 'Project shortname',
                     'mount_point': 'Repository mount point'
                 }
                 error_msg += '%s: %s ' % (names[msg], c.form_errors[msg])
                 flash(error_msg, 'error')
             return dict(prefix=prefix,
                         shortname=shortname,
                         mount_point=mount_point)
         nbhd = M.Neighborhood.query.get(url_prefix='/%s/' % prefix)
         if not nbhd:
             flash('Neighborhood with prefix %s not found' % prefix,
                   'error')
             return dict(prefix=prefix,
                         shortname=shortname,
                         mount_point=mount_point)
         c.project = M.Project.query.get(shortname=shortname,
                                         neighborhood_id=nbhd._id)
         if not c.project:
             flash(
                 'Project with shortname %s not found in neighborhood %s' %
                 (shortname, nbhd.name), 'error')
             return dict(prefix=prefix,
                         shortname=shortname,
                         mount_point=mount_point)
         c.app = c.project.app_instance(mount_point)
         if not c.app:
             flash(
                 'Mount point %s not found on project %s' %
                 (mount_point, c.project.shortname), 'error')
             return dict(prefix=prefix,
                         shortname=shortname,
                         mount_point=mount_point)
         source_url = c.app.config.options.get('init_from_url')
         source_path = c.app.config.options.get('init_from_path')
         if not (source_url or source_path):
             flash('%s does not appear to be a cloned repo' % c.app,
                   'error')
             return dict(prefix=prefix,
                         shortname=shortname,
                         mount_point=mount_point)
         allura.tasks.repo_tasks.reclone_repo.post(prefix=prefix,
                                                   shortname=shortname,
                                                   mount_point=mount_point)
         flash('Repository is being recloned')
     else:
         prefix = 'p'
         shortname = ''
         mount_point = ''
     return dict(prefix=prefix,
                 shortname=shortname,
                 mount_point=mount_point)
Example #51
0
 def update(self,
            title=None,
            text=None,
            labels=None,
            viewable_by=None,
            new_viewable_by=None,
            **kw):
     activity_verb = 'created'
     if not title:
         flash('You must provide a title for the page.', 'error')
         redirect('edit')
     title = title.replace('/', '-')
     if not self.page:
         # the page doesn't exist yet, so create it
         self.page = WM.Page.upsert(self.title)
         self.page.viewable_by = ['all']
     else:
         require_access(self.page, 'edit')
         activity_verb = 'modified'
     name_conflict = None
     if self.page.title != title:
         name_conflict = WM.Page.query.find(
             dict(app_config_id=c.app.config._id,
                  title=title,
                  deleted=False)).first()
         if name_conflict:
             flash('There is already a page named "%s".' % title, 'error')
         else:
             if self.page.title == c.app.root_page_name:
                 WM.Globals.query.get(
                     app_config_id=c.app.config._id).root = title
             self.page.title = title
             activity_verb = 'renamed'
     self.page.text = text
     if labels:
         self.page.labels = labels.split(',')
     else:
         self.page.labels = []
     self.page.commit()
     g.spam_checker.check(text,
                          artifact=self.page,
                          user=c.user,
                          content_type='wiki')
     g.director.create_activity(c.user,
                                activity_verb,
                                self.page,
                                target=c.project)
     if new_viewable_by:
         if new_viewable_by == 'all':
             self.page.viewable_by.append('all')
         else:
             user = c.project.user_in_project(str(new_viewable_by))
             if user:
                 self.page.viewable_by.append(user.username)
     if viewable_by:
         for u in viewable_by:
             if u.get('delete'):
                 if u['id'] == 'all':
                     self.page.viewable_by.remove('all')
                 else:
                     user = M.User.by_username(str(u['id']))
                     if user:
                         self.page.viewable_by.remove(user.username)
     redirect('../' + h.really_unicode(self.page.title).encode('utf-8') +
              ('/' if not name_conflict else '/edit'))
Example #52
0
    def put(self, item_id, folder_id='0'):
        """
        :param item_id:
        :param folder_id: id of the folder, in a style like 'workspace_14__content_1586'
        :return:
        """
        # TODO - SECURE THIS
        workspace = tmpl_context.workspace
        item_id = int(item_id)
        new_workspace, new_parent = convert_id_into_instances(folder_id)

        if new_workspace != workspace:
            # check that user is at least
            # - content manager in current workspace
            # - content manager in new workspace
            user = tmpl_context.current_user

            if user.get_role(workspace) < UserRoleInWorkspace.CONTENT_MANAGER:
                tg.flash(_('You are not allowed '
                           'to move this folder'), CST.STATUS_ERROR)
                tg.redirect(self.parent_controller.url(item_id))

            if user.get_role(
                    new_workspace) < UserRoleInWorkspace.CONTENT_MANAGER:
                tg.flash(
                    _('You are not allowed to move '
                      'this folder to this workspace'), CST.STATUS_ERROR)
                tg.redirect(self.parent_controller.url(item_id))

            api = ContentApi(tmpl_context.current_user)
            item = api.get_one(item_id, ContentType.Any, workspace)

            with new_revision(item):
                api.move_recursively(item, new_parent, new_workspace)

            next_url = tg.url('/workspaces/{}/folders/{}'.format(
                new_workspace.workspace_id, item_id))
            if new_parent:
                tg.flash(
                    _('Item moved to {} (workspace {})').format(
                        new_parent.label, new_workspace.label), CST.STATUS_OK)
            else:
                tg.flash(
                    _('Item moved to workspace {}').format(
                        new_workspace.label))

            tg.redirect(next_url)

        else:
            # Default move inside same workspace
            api = ContentApi(tmpl_context.current_user)
            item = api.get_one(item_id, ContentType.Any, workspace)
            with new_revision(item):
                api.move(item, new_parent)
            next_url = self.parent_controller.url(item_id)
            if new_parent:
                tg.flash(
                    _('Item moved to {}').format(new_parent.label),
                    CST.STATUS_OK)
            else:
                tg.flash(_('Item moved to workspace root'))

            tg.redirect(next_url)
Example #53
0
 def flash_unicode(self):
     tg.flash(u"Привет, мир!")
     tg.redirect("/flash_after_redirect")
Example #54
0
 def _default(self, *args, **kw):
     """Maneja las urls no encontradas"""
     flash(_('Recurso no encontrado'), 'warning')
     redirect('/')
     return dict(page='index')
Example #55
0
 def flash_redirect(self):
     tg.flash("Wow, flash!")
     tg.redirect("/flash_after_redirect")
Example #56
0
 def flash_no_redirect(self):
     tg.flash("Wow, flash!")
     return tg.get_flash()
Example #57
0
def rate_limit():
    if BM.BlogPost.is_limit_exceeded(c.app.config, user=c.user):
        msg = 'Create/edit rate limit exceeded. '
        log.warn(msg + c.app.config.url())
        flash(msg + 'Please try again later.', 'error')
        redirect(c.app.config.url())
Example #58
0
 def bigflash_redirect(self):
     tg.flash('x' * 5000)
     tg.redirect('/flash_after_redirect')
Example #59
0
 def post(self, name, languageid, description):
     """create a new Category"""
     category = Category(name, languageid, description)
     DBSession.add(category)
     flash('%s %s' % (_('Created Category:'), category.id), 'ok')
     return dict(redirect_to=url('/admin/category/'))
Example #60
0
    def put(self, new_profile):
        # FIXME - Allow only self password or operation for managers
        current_user = tmpl_context.current_user
        user = tmpl_context.user

        group_api = GroupApi(current_user)

        if current_user.user_id == user.user_id:
            tg.flash(_('You can\'t change your own profile'), CST.STATUS_ERROR)
            tg.redirect(self.parent_controller.url())

        redirect_url = self.parent_controller.url(skip_id=True)

        if new_profile not in self.allowed_profiles:
            tg.flash(_('Unknown profile'), CST.STATUS_ERROR)
            tg.redirect(redirect_url)

        pod_user_group = group_api.get_one(Group.TIM_USER)
        pod_manager_group = group_api.get_one(Group.TIM_MANAGER)
        pod_admin_group = group_api.get_one(Group.TIM_ADMIN)

        flash_message = _(
            'User updated.')  # this is the default value ; should never appear

        if new_profile == UserProfileAdminRestController._ALLOWED_PROFILE_USER:
            if pod_user_group not in user.groups:
                user.groups.append(pod_user_group)

            try:
                user.groups.remove(pod_manager_group)
            except:
                pass

            try:
                user.groups.remove(pod_admin_group)
            except:
                pass

            flash_message = _('User {} is now a basic user').format(
                user.get_display_name())

        elif new_profile == UserProfileAdminRestController._ALLOWED_PROFILE_MANAGER:
            if pod_user_group not in user.groups:
                user.groups.append(pod_user_group)
            if pod_manager_group not in user.groups:
                user.groups.append(pod_manager_group)

            try:
                user.groups.remove(pod_admin_group)
            except:
                pass

            flash_message = _('User {} can now workspaces').format(
                user.get_display_name())

        elif new_profile == UserProfileAdminRestController._ALLOWED_PROFILE_ADMIN:
            if pod_user_group not in user.groups:
                user.groups.append(pod_user_group)
            if pod_manager_group not in user.groups:
                user.groups.append(pod_manager_group)
            if pod_admin_group not in user.groups:
                user.groups.append(pod_admin_group)

            flash_message = _('User {} is now an administrator').format(
                user.get_display_name())

        else:
            logger.error(
                self,
                'Trying to change user {} profile with unexpected profile {}'.
                format(user.user_id, new_profile))
            tg.flash(_('Unknown profile'), CST.STATUS_ERROR)
            tg.redirect(redirect_url)

        DBSession.flush()
        tg.flash(flash_message, CST.STATUS_OK)
        tg.redirect(redirect_url)