예제 #1
0
파일: root.py 프로젝트: sgip/prueba
    def EliminarFase(self, proy_id, fase_id, **kw):
	DBSession.delete(DBSession.query(Fase).get(fase_id))
	#DBSession.delete(DBSession.query(Permission).filter_by(permission_name=('ConsultarUsuario' + usuario_id)).one())
	#DBSession.delete(DBSession.query(Permission).filter_by(permission_name=('EditarUsuario' + usuario_id)).one())
	#DBSession.delete(DBSession.query(Permission).filter_by(permission_name=('EliminarUsuario' + usuario_id)).one())
	#DBSession.delete(DBSession.query(Group).filter_by(group_name=('RolPorDefecto' + usuario_id)).one())
	redirect("/DefinirFases/"+proy_id)
예제 #2
0
파일: root.py 프로젝트: sgip/prueba
    def TipoDeItem(self, proyecto_id, fase_id, **kw):
	proyecto = DBSession.query(Proyecto).filter_by(codproyecto=proyecto_id).one()
	fase = DBSession.query(Fase).filter_by(codfase=fase_id).one()
	fases = proyecto.fases
	if not isinstance(fases, list):
		fases = [fases]
	return dict(page='Tipos de item', proyecto=proyecto, fases=fases, fase=fase, value=kw)
예제 #3
0
  def calcular(self):
	self.hash[self.codItem]=self.codItem
	listaItemInicio = list()
	listaItemFin= list()
	aux = list()
	impacto = 0
	while(self.cola):
		coditemActual = self.cola.popleft()
		itemNuevo =  DBSession.query(Item).filter_by(coditem=coditemActual).one()
		print "calculando....................." + str(coditemActual) + " =========== " + str(itemNuevo.complejidad)
		impacto = impacto + itemNuevo.complejidad

		listaItemInicio = DBSession.query(Relacion).filter_by(coditeminicio=itemNuevo.coditem).all()
                for x in listaItemInicio:
			if not self.hash.has_key(x.coditemfin):
                    		#aux.append(x.coditemfin)
                		self.cola.append(x.coditemfin)
				self.hash[x.coditemfin]=x.coditemfin

                listaItemFin = DBSession.query(Relacion).filter_by(coditemfin=itemNuevo.coditem).all()
                for x in listaItemFin:
			if not self.hash.has_key(x.coditeminicio):
				#aux.append(x.coditemfin)
				self.cola.append(x.coditeminicio)
				self.hash[x.coditeminicio]=x.coditeminicio

	#	for coditem in aux:
	#		self.cola.append(coditem)
	#		self.hash[coditem]=coditem
	return (impacto)    
예제 #4
0
파일: root.py 프로젝트: sgip/prueba
    def IngresarFase(self, proyecto_id, fase_id, **kw):
	proyecto = DBSession.query(Proyecto).filter_by(codproyecto=proyecto_id).one()
	fase = DBSession.query(Fase).filter_by(codfase=fase_id).one()
	items = fase.items
	if not isinstance(items, list):
		items = [items]
	return dict(modelname='Proyecto', proyecto=proyecto, fase=fase, items=items, value=kw)
예제 #5
0
파일: root.py 프로젝트: sgip/prueba
    def editarFase(self, proy_id, fase_id, nombre="", descripcion="", **kw):
	fase = DBSession.query(Fase).filter_by(codfase=fase_id).one()
	fase.nombre = nombre
	fase.descripcion = descripcion
	DBSession.flush()
	flash("La fase fue actualizada con exito")
	redirect("/DefinirFases/"+proy_id)
예제 #6
0
파일: root.py 프로젝트: sgip/prueba
    def CrearTipoItemBasico(self, proyecto_id, fase):
	t = Tipoitem()
	t.nombre='Basico'
	t.fase=fase
	c1 = Campo()
	c1.nombre = 'Nombre'
	c1.tipo = 'String'
	c2 = Campo()
	c2.nombre = 'Complejidad'
	c2.tipo = 'Int'
	c3 = Campo()
	c3.nombre = 'Prioridad'
	c3.tipo = 'Int'
	c4 = model.Campo()
	c4.nombre = 'Version'
	c4.tipo = 'Int'
	c5 = model.Campo()
	c5.nombre = 'Estado'
	c5.tipo = 'String'
	c6 = model.Campo()
	c6.nombre = 'Fecha'
	c6.tipo = 'Date'
	t.campos.append(c1)
	t.campos.append(c2)
	t.campos.append(c3)
	t.campos.append(c4)
	t.campos.append(c5)
	t.campos.append(c6)
	DBSession.flush()
예제 #7
0
 def calcular(self):
     self.hash[self.codItem]=self.codItem
     listaItemInicio = list()
     listaItemFin= list()
     aux = list()
     impacto = 0
     ban=1
     
     while(self.cola):
         coditemActual = self.cola.popleft()
         itemNuevo =  DBSession.query(Item).filter_by(coditem=coditemActual).one()
         self.itemsImplicados.append(itemNuevo)
         
         nombreNodo = itemNuevo.nombre + "   " +itemNuevo.fase.nombre + "   " + str(itemNuevo.complejidad)  
         itemOrigen = pydot.Node(nombreNodo, style="filled", fillcolor="red")
         if ban == 1:
             self.grafo.add_node(itemOrigen)
             ban = 0
         
         
         if not itemNuevo.codfase in self.codFasesImplicadas:
             self.codFasesImplicadas.append(itemNuevo.codfase)
             
         print "calculando....................." + str(coditemActual) + " =========== " + str(itemNuevo.complejidad)
         impacto = impacto + itemNuevo.complejidad
         
         listaItemInicio = DBSession.query(Relacion).filter_by(coditeminicio=itemNuevo.coditem).all()
         
         for x in listaItemInicio:
             if not self.hash.has_key(x.coditemfin):
                 itemDestino =  DBSession.query(Item).filter_by(coditem=x.coditemfin).one()
                 nombreNodoDestino = itemDestino.nombre + "   " +itemDestino.fase.nombre + "   " + str(itemDestino.complejidad)  
                 itemDestino = pydot.Node(nombreNodoDestino, style="filled", fillcolor="blue")
                 self.grafo.add_node(itemDestino)
                 enlace = pydot.Edge(nombreNodo, nombreNodoDestino)
                 self.grafo.add_edge(enlace) 
                             
                 self.cola.append(x.coditemfin)
                 self.hash[x.coditemfin]=x.coditemfin
         
         listaItemFin = DBSession.query(Relacion).filter_by(coditemfin=itemNuevo.coditem).all()
         for x in listaItemFin:
             if not self.hash.has_key(x.coditeminicio):
                 itemDestino =  DBSession.query(Item).filter_by(coditem=x.coditeminicio).one()
                 nombreNodoDestino = itemDestino.nombre + "   " +itemDestino.fase.nombre + "   " + str(itemDestino.complejidad)  
                 itemDestino = pydot.Node(nombreNodoDestino, style="filled", fillcolor="blue")
                 self.grafo.add_node(itemDestino)
                 enlace = pydot.Edge(nombreNodoDestino,nombreNodo)
                 self.grafo.add_edge(enlace)
                 
                 self.cola.append(x.coditeminicio)
                 self.hash[x.coditeminicio]=x.coditeminicio
       
     #    for coditem in aux:
     #        self.cola.append(coditem)
     #        self.hash[coditem]=coditem
     self.grafo.write_png("/home/lilian/tg2env/prueba/prueba/public/impacto/nombre.png")
     
     return (impacto )
예제 #8
0
파일: Ciclos.py 프로젝트: sgip/ultimo-repo
 def calcular(self):
       item = DBSession.query(Item).filter_by(coditem=self.codItem).one()
       itemFase = item.fase.items
       auxItemFase = list()
       padres = list()
       hijos = list()
       relacion_act = list() 
       listaItem = list()
       pila = list() 
       visitados = list()
       ciclo = 0
       
       padres.append(self.codItem)
       hijos.append(self.itemFin)
       listaItem.append(self.codItem)
       
       for i in itemFase:   
           auxItemFase.append(i.coditem)
          
       for x in itemFase:
           relacionAux = DBSession.query(Relacion).filter_by(coditeminicio=x.coditem).filter_by(tipo='padre-hijo').all()
           for j in relacionAux:
               padres.append(j.coditeminicio)
               listaItem.append(j.coditeminicio)
               hijos.append(j.coditemfin)
       
       for inicio in padres:
           pila.append(inicio)
           while(pila and ciclo==0):
               origen = pila.pop()
               if not origen in visitados:
                   visitados.append(origen)
               while origen in listaItem:
                   i = listaItem.index(origen)
                   listaItem[i] = -1
             
                   if hijos[i] in visitados:#mirar si no fue visistado.hay ciclo y se pasa al sgt valor en la lista padres
                       pila = list()
                       visitados = list()
                       listaItem = list()
                       ciclo = 1
                       return ciclo 
                       break
                   else:
                       pila.append(hijos[i])
                       visitados.append(hijos[i])
           if ciclo==1:
               break
           listaItem=list()
           visitados=list()
           for x in padres:
               listaItem.append(x)
               
       return ciclo
예제 #9
0
파일: root.py 프로젝트: sgip/prueba
    def editarRol(self, rol_id, nombre, descripcion, permisos=None, **kw):
	rol = DBSession.query(Group).filter_by(group_id=rol_id).one()
	rol.group_name = nombre
	rol.group_description = descripcion
	
	if permisos is not None:
		if not isinstance(permisos, list):
			permisos = [permisos]
		permisos = [DBSession.query(Permission).get(permiso) for permiso in permisos]
	else:
		permisos=list()
	rol.permissions = permisos
	DBSession.flush()
	flash("El rol fue actualizado con exito")
	redirect("/ListarRoles")
예제 #10
0
파일: root.py 프로젝트: sgip/prueba
    def crearFase(self, proy_id, **kw):
	fase = Fase()
	fase.nombre = kw['nombre']
	fase.descripcion = kw['descripcion']
	fase.estado = "definicion"
	import datetime
	fase.fecha = datetime.date.today()
	proyecto = DBSession.query(Proyecto).filter_by(codproyecto=proy_id).one()
	fase.proyecto = proyecto
	proyecto.fases.append(fase)
	#fase.codproyecto=int(proy_id)
	DBSession.add(fase)
	self.CrearTipoItemBasico(proy_id, fase)
    	flash("La fase fue creada con exito")
    	redirect("/DefinirFases/"+proy_id)
예제 #11
0
파일: root.py 프로젝트: sgip/prueba
    def IniciarProyecto(self, proyecto_id, **kw):
	proyecto = DBSession.query(Proyecto).filter_by(codproyecto=proyecto_id).one()
	proyecto.cantfases=len(proyecto.fases)
	proyecto.estado="desarrollo"
	fases = DBSession.query(Fase).filter_by(codproyecto=proyecto_id).order_by(Fase.codfase).all()
	i=1
	for fase in fases:
		fase.orden=i;
		if i==1:
			fase.estado="desarrollo"
		else:
			fase.estado="inicial"
		i=i+1
	DBSession.flush()
	redirect("/ListarProyectos")
예제 #12
0
파일: root.py 프로젝트: sgip/prueba
    def ModificarItem(self, proyecto_id, fase_id, item_id, **kw):
	print kw
	item = DBSession.query(Item).filter_by(coditem=item_id).one()
	tipoitem = item.tipoitem
	###Listar items de la fase anterior y de la fase posterior
	proyecto = DBSession.query(Proyecto).filter_by(codproyecto=proyecto_id).one()
	orden_fase = item.fase.orden
	orden_izq = orden_fase-1
	orden_der =  orden_fase+1
	items_izq=list()
	items_der=list()
	if orden_fase > 1:
		fase_izq = DBSession.query(Fase).filter_by(codproyecto=proyecto_id).filter_by(orden=orden_izq).one()
		items_izq = fase_izq.items
	if orden_fase < proyecto.cantfases:
		fase_der = DBSession.query(Fase).filter_by(codproyecto=proyecto_id).filter_by(orden=orden_der).one()
		items_der = fase_der.items
	return dict(page='Edicion de Items', proyecto_id=proyecto_id, fase_id=fase_id, item=item, tipoitem=tipoitem, items_izq=items_izq, items_der=items_der, value=kw)
예제 #13
0
파일: root.py 프로젝트: sgip/prueba
    def EditarFase(self, proyecto_id, fase_id, **kw):
	fase=Fase()
	if ('nombre' in kw or 'description' in kw):
		fase.nombre=kw['nombre']
		fase.descripcion=kw['descripcion'] 
	else:
		fase = DBSession.query(Fase).filter_by(codfase=fase_id).one()
	#roles_del_usuario = usuario.groups #Roles del usuario
	#todos_los_roles = DBSession.query(Group).all() #Todos los roles de la BD
	return dict(page='Edicion de fases', fase_id=fase_id, proy_id=proyecto_id, fase=fase, value=kw)
예제 #14
0
파일: root.py 프로젝트: sgip/prueba
    def editarUsuario(self, usuario_id, username, contrasena, nombre_completo, telefono, direccion, email, roles=None, **kw):
	usuario = DBSession.query(User).filter_by(user_id=usuario_id).one()
	usuario.user_name = username
	usuario.password = contrasena
	usuario.user_fullname = nombre_completo
	usuario.user_telefono = telefono
	usuario.user_direccion = direccion
	usuario.email_address = email
		
	if roles is not None:
		if not isinstance(roles, list):
			roles = [roles]
		roles = [DBSession.query(Group).get(rol) for rol in roles]
	else:
		roles=list()
	usuario.groups = roles 
	DBSession.flush()
	flash("El usuario fue actualizado con exito")
	redirect("/ListarUsuarios")
예제 #15
0
파일: root.py 프로젝트: sgip/prueba
    def ListarProyectos(self, **kw):
    	proyectos = DBSession.query(Proyecto).order_by(Proyecto.codproyecto)
	## Paginacion
	from webhelpers import paginate
	count = proyectos.count()
	page = int(kw.get('page', '1'))
	currentPage = paginate.Page(proyectos, page, item_count=count, items_per_page=5,)
	proyectos = currentPage.items
	### Para determinar si el usuario actualmente loggeado tiene permiso para crear nuevos roles
	permiso_para_crear = has_permission('crear_usuario')
	return dict(page='Listado de Proyectos', proyectos=proyectos, currentPage = currentPage, p=permiso_para_crear)  
예제 #16
0
파일: root.py 프로젝트: sgip/prueba
    def ListarUsuarios(self, **kw):
    	usuarios = DBSession.query(User).order_by(User.user_id)
	## Paginacion
	from webhelpers import paginate
	count = usuarios.count()
	page = int(kw.get('page', '1'))
	currentPage = paginate.Page(usuarios, page, item_count=count, items_per_page=5,)
	usuarios = currentPage.items
	### Para determinar si el usuario actualmente loggeado tiene permiso para crear nuevos roles
	permiso_para_crear = has_permission('crear_usuario')
	### Para determinar si el usuario actualmente loggeado tiene permiso para editar roles existentes
	return dict(page='Listado de Usuarios', usuarios=usuarios, currentPage = currentPage, p=permiso_para_crear)
예제 #17
0
파일: root.py 프로젝트: sgip/prueba
    def crearItem(self, proyecto_id, fase_id, tipoitem_id, **kw):
	#print tipoitem_id
	item = Item()
	item.nombre=kw['nombre']
	item.complejidad=kw['complejidad']
	item.prioridad=kw['prioridad']
	item.version=1
	item.estado='desarrollo'
	import datetime
	item.fecha=datetime.date.today()
	tipoitem = DBSession.query(Tipoitem).filter_by(codtipoitem=tipoitem_id).one()
	item.tipoitem = tipoitem
	fase = DBSession.query(Fase).filter_by(codfase=fase_id).one()
	#print fase
	#print item.fase
	item.fase = fase
	#print tipoitem
	DBSession.add(item)
	fase.items.append(item)
	tipoitem.items.append(item)
	redirect("/IngresarFase/"+proyecto_id+"/"+fase_id)
예제 #18
0
    def graficar(self):
	c = 0
	implicados = list()
	print "pydot-------_",self.itemsImplicados[0].coditem
	implicados.append(self.itemsImplicados[0].coditem)
	while(implicados):
		print "pydot-------_"
		coditemActual = implicados.popleft()
                itemNuevo =  DBSession.query(Item).filter_by(coditem=coditemActual).one()
		nombreNodo = itemNuevo.nombre + "   " +itemNuevo.fase.nombre + "   " + str(itemNuevo.complejidad)
		if c == 0:
	                itemOri = pydot.Node(nombreNodo, style="filled", fillcolor="red")
			c = 1
		else:
			itemOri = pydot.Node(nombreNodo, style="filled", fillcolor="blue")
		self.grafo.add_node(itemOri)
		padres = DBSession.query(Relacion).filter_by(coditemfin=itemNuevo.coditem).all()
		for padre in padres:
			print "padres" + str(padre.coditeminicio) 
			implicados.append(padre.coditeminicio)
			itemOrigen =  DBSession.query(Item).filter_by(coditem=padre.coditeminicio).one()
			nombreNodoOrigen = itemOrigen.nombre + "   " +itemOrigen.fase.nombre + "   " + str(itemOrigen.complejidad)  
			itemOrigen = pydot.Node(nombreNodoOrigen, style="filled", fillcolor="blue")
			self.grafo.add_node(itemOrigen)
			enlace = pydot.Edge(nombreNodoOrigen,nombreNodo)
			self.grafo.add_edge(enlace) 
		hijos = DBSession.query(Relacion).filter_by(coditeminicio=itemNuevo.coditem).all()
		for hijo in hijos:
			print "hijos" + str(hijo.coditemfin)
   			implicados.append(padre.coditemfin)
			itemDestino =  DBSession.query(Item).filter_by(coditem=hijo.coditemfin).one()
			nombreNodoDestino = itemDestino.nombre + "   " +itemDestino.fase.nombre + "   " + str(itemDestino.complejidad)  
			itemDestino = pydot.Node(nombreNodoDestino, style="filled", fillcolor="blue")
			self.grafo.add_node(itemDestino)
			enlace = pydot.Edge(nombreNodo,nombreNodoDestino)
			self.grafo.add_edge(enlace) 
	
	self.grafo.write_png("/home/osmar/Escritorio/presentacion/prueba/prueba/public/impacto/imagen.png")
예제 #19
0
파일: Ciclos.py 프로젝트: sgip/sgip-repo
 def tieneAntecesor(self):
       #trae el item correspondiente
       item = DBSession.query(Item).filter_by(coditem=self.codItem).one() 
       # los items de la fase actual
       itemFase = item.fase.items 
       faseItemAnt = int(item.fase.codfase) -1  
       #los antecesores y sucesores del item dado
       antecesores = DBSession.query(Relacion).filter_by(coditemfin=self.codItem).filter_by(tipo='antecesor-sucesor').all()
       #fase anterior a la actual 
       faseAnt = DBSession.query(Fase).filter_by(codfase=faseItemAnt).one()
       #items de la fase anterior
       itemFaseAnt = DBSession.query(Item).filter_by(fase=faseAnt).all()
       
       itemFaseAnterior = list()
       pila = list()
         
       print "########################### items fase anterior ####################################### ", self.codItem 
       for h in itemFaseAnt:
           itemFaseAnterior.append(h.coditem)
           print h.coditem
       print "//////////////////////////"
           
       #si tiene una antecesor directo, retorna que tiene antecesor    
       for j in antecesores:
           if j.coditeminicio in auxItemFaseAnterior:
               return 1   
       
       #los items que son padres del actual
       padres = DBSession.query(Relacion).filter_by(coditemfin=self.codItem).filter_by(tipo='padre-hijo').all()
       for i in padres:
           pila.append(i.coditeminicio)  
         
       while(pila):
           x = pila.pop()
           antecesores = DBSession.query(Relacion).filter_by(coditemfin=x).filter_by(tipo='antecesor-sucesor').all()
           cantidad=0
           print "###################################################################"
           for m in antecesores:
               cantidad = cantidad + 1
               m.coditeminicio
           print "###################################################################"
           if cantidad == 0:
               print "nulooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo"
               antecesores = DBSession.query(Relacion).filter_by(coditemfin=x).filter_by(tipo='padre-hijo').all()
               for i in antecesores:   
                   pila.append(i.coditeminicio)
           else:
               for j in antecesores:
                   if j.coditeminicio in itemFaseAnterior:
                       return 1
       return 0
                   
예제 #20
0
파일: root.py 프로젝트: sgip/prueba
    def DefinirFases(self, proyecto_id, **kw):
	proyecto = DBSession.query(Proyecto).filter_by(codproyecto=proyecto_id).one()
	fases = list()
	#for fase in proyecto.fases:
	#	fases.append(int(fase.codfase));
	#print proyecto.nombre
	#print proyecto.codproyecto
	#print proyecto.estado
	#print proyecto.fecha
	#print proyecto.fases
	#print type(proyecto.fases)
	fases = proyecto.fases
	if not isinstance(fases, list):
		fases = [fases]
	return dict(page='Definicion de fases', proyecto_id=proyecto_id, proyecto=proyecto, fases=fases, value=kw)
예제 #21
0
파일: root.py 프로젝트: sgip/prueba
    def NuevoItem(self, proyecto_id, fase_id, tipo_item, **kw):
	#en caso de error de validacion al crear item
	if 'nombre' in kw:
		nombre = kw['nombre']
	else:	
		nombre=""
	if 'complejidad' in kw:
		complejidad=kw['complejidad']
	else: 
		complejidad=""
	if 'prioridad' in kw:
		prioridad=kw['prioridad']
	else:
		prioridad=""
	tipoitem = DBSession.query(Tipoitem).filter_by(codtipoitem=tipo_item).one()
	return dict(page='Creacion de Items', proyecto_id=proyecto_id, fase_id=fase_id, tipo_item=tipoitem, nombre=nombre, complejidad=complejidad, prioridad=prioridad, value=kw)
예제 #22
0
 def setup(self):
     try:
         new_attrs = {}
         new_attrs.update(self.attrs)
         new_attrs.update(self.do_get_dependencies())
         self.obj = self.klass(**new_attrs)
         DBSession.add(self.obj)
         DBSession.flush()
         return self.obj
     except:
         DBSession.rollback()
         raise
예제 #23
0
파일: __init__.py 프로젝트: sgip/prueba
 def setUp(self):
     """Prepare model test fixture."""
     try:
         new_attrs = {}
         new_attrs.update(self.attrs)
         new_attrs.update(self.do_get_dependencies())
         self.obj = self.klass(**new_attrs)
         DBSession.add(self.obj)
         DBSession.flush()
         return self.obj
     except:
         DBSession.rollback()
         raise
예제 #24
0
파일: root.py 프로젝트: sgip/prueba
    def ListarRoles(self, **kw):
    	roles = DBSession.query(Group).order_by(Group.group_id)
	### Para determinar si el usuario actualmente loggeado tiene permiso para crear nuevos roles
	permiso_para_crear = has_permission('crear_rol')
	### Para determinar si el usuario actualmente loggeado tiene permiso para editar roles existentes
	r=list()
	editar=list()
	identity = request.environ['repoze.who.identity']
	usuario = identity['user']
	cant=0
	for rol in roles:
		permiso = 'ConsultarRol' + str(rol.group_id)
		if has_permission(permiso):
			r.append(rol)
		permiso = 'EditarRol' + str(rol.group_id)
		if has_permission(permiso):
			editar.append(True)
		else:
			editar.append(False)
		cant = cant +1
		#can_edit = has_permission(permiso)
		#print can_edit
		#checker = user_can_edit(rol.group_id)
		#can_edit = checker.is_met(request.environ)
		#if can_edit != Nonw
		#	my_list.append(True)
		#if can_edit == None
		#	my_list.append(False)
	print type(roles)
	print type(r)
	## Paginacion
	from webhelpers import paginate
	count = cant
	page = int(kw.get('page', '1'))
	currentPage = paginate.Page(r, page, item_count=count, items_per_page=5,)
	r = currentPage.items
	
	
	return dict(page='Listado de Roles', roles=r, currentPage = currentPage, p=permiso_para_crear, editar=editar)
예제 #25
0
파일: root.py 프로젝트: sgip/prueba
    def editarItem(self, proyecto_id, fase_id, item_id, **kw):
	item = DBSession.query(Item).filter_by(coditem=item_id).one()
	item.nombre=kw['nombre']
	item.complejidad=kw['complejidad']
	item.prioridad=kw['prioridad']
	item.version=1
	item.estado='definicion'
	import datetime
	item.fecha=datetime.date.today()
	DBSession.flush()
	##Crear las relaciones
	if 'items_izq' in kw:
		items_izq = kw['items_izq']
		if not isinstance(items_izq, list):
			items_izq = [items_izq]
	else:
		items_izq=list()
	if 'items_der' in kw:
		items_der = kw['items_der']
		if not isinstance(items_der, list):
			items_der = [items_der]
	else:
		items_der=list()
	for item in items_izq:
		relacion = Relacion()
		relacion.coditeminicio= int(item)
		relacion.coditemfin=item_id
		relacion.tipo='antecesor-sucesor'
		DBSession.add(relacion)
	for item in items_der:
		relacion = Relacion()
		relacion.coditeminicio= item_id
		relacion.coditemfin=int(item)
		relacion.tipo='antecesor-sucesor'
		DBSession.add(relacion)
	redirect("/IngresarFase/"+proyecto_id+"/"+fase_id)
예제 #26
0
파일: auth.py 프로젝트: sgip/ultimo-repo
 def by_email_address(cls, email):
     """Return the user object whose email address is ``email``."""
     return DBSession.query(cls).filter_by(email_address=email).first()
예제 #27
0
파일: __init__.py 프로젝트: sgip/prueba
 def test_query_obj(self):
     """Model objects can be queried"""
     obj = DBSession.query(self.klass).one()
     for key, value in self.attrs.iteritems():
         assert_equals(getattr(obj, key), value)
예제 #28
0
 def tearDown(self):
     DBSession.rollback()
예제 #29
0
 def test_query_obj(self):
     obj = DBSession.query(self.klass).one()
     for key, value in self.attrs.iteritems():
         assert_equals(getattr(obj, key), value)
예제 #30
0
 def by_user_name(cls, username):
     """Return the user object whose user name is ``username``."""
     return DBSession.query(cls).filter(cls.user_name == username).first()
예제 #31
0
파일: auth.py 프로젝트: sgip/ultimo-repo
 def by_user_name(cls, username):
     """Return the user object whose user name is ``username``."""
     return DBSession.query(cls).filter_by(user_name=username).first()
예제 #32
0
 def by_email_address(cls, email):
     """Return the user object whose email address is ``email``."""
     return DBSession.query(cls).filter(cls.email_address == email).first()