def asociar_usuario_fase(self, usuario_id, fase_id): """ Asocia los permisos de un usuario con una fase, asi los usuarios que posean el rol estaran asociados a la fase. @type usuario_id : String @param usuario_id : Codigo del rol @type fase_id : Integer @param fase_id : Identificador de la fase @rtype : Rol @return : El rol que es aplicado a la fase. """ fase = DBSession.query(Fase).get(fase_id) #Se obtienen los permisos del template permisos_rol = self.distinct(DBSession.query(Permiso).\ filter(RolPermisoProyecto.permiso_id == Permiso.permiso_id).\ filter(RolPermisoProyecto.proyecto_id == fase.proyecto) ) #Se se asocian el rol con la fase for permiso in permisos_rol: rpu = UsuarioPermisoFase() rpu.fase_id = fase_id rpu.usuario_id = usuario_id rpu.permiso_id = permiso.permiso_id #Asocia el rol con los permisos y la fase DBSession.add(rpu)
def borrarRelacion(self, item1, item2, idfase, **kw):
if not self.puede_borrar(item1, item2, idfase):
flash ("No se peude borrar la relacion! deja huerfanos", 'warning')
redirect("/miproyecto/fase/relacion/list/"+idfase)
#auditar items y aumentar su version
item_1 = DBSession.query(Item).get(item1)
item_2 = DBSession.query(Item).get(item2)
item_util.audit_item(item_1)
item_util.audit_item(item_2)
item_1.version += 1
item_2.version += 1
item_1.estado = 3
item_2.estado = 3
DBSession.add(item_1)
DBSession.add(item_2)
DBSession.delete(DBSession.query(RelacionItem).\
filter(RelacionItem.id_item_actual==item1).\
filter(RelacionItem.id_item_relacionado==item2).\
one())
#marcar en revision los relacionados
fase = DBSession.query(Fase).get(item_1.fase)
grafo = item_util.proyectGraphConstructor(fase.proyecto)
item_util.marcar_en_revision(grafo, item_1.id_item)
item_util.marcar_en_revision(grafo, item_2.id_item)
flash("Se ha eliminado la relacion: "+item1+" <--> "+item2)
redirect("/miproyecto/fase/relacion/list/"+idfase)
def post_delete(self, *args, **kw):
"""This is the code that actually deletes the record"""
pks = self.provider.get_primary_fields(self.model)
d = {}
for i, arg in enumerate(args):
d[pks[i]] = arg
"""extraer el idFase para poder retornar en el estado anterior """
idfase= DBSession.query(Item.idFase).filter_by(id=d['id']).first()
"""------------------------------------------------------------"""
"""Se crea objeto y cambia de estado """
itemeDelete=DBSession.query(Item).filter_by(id=d['id']).first()
itemeDelete.estado="borrado"
itemeDelete.ultimaversion=0
DBSession.add(itemeDelete)
"""---------Se borra las relaciones del Item Borrado--------------"""
relaciones= DBSession.query(RelacionItem).filter((RelacionItem.idItem1==d['id']) | (RelacionItem.idItem2==d['id'])).all()
longitud=len(relaciones)
for x in range(longitud):
DBSession.delete(relaciones[x])
"""---------------------------------------------------------------"""
#self.provider.delete(self.model, d)
#self.provider.delete(self.model, d)
#redirect('./' + '../' * (len(pks) - 1))
raise redirect('/item/?fid='+str(idfase[0]))
def asignar_rol_usuario(self,usuario_id , cod_rol, id_proyecto): """ Asigna un rol asociado a un proyecto al usuario determinado. @type usuario_id : Integer @param usuario_id : Identificador del usuario @type cod_rol : String @param cod_rol : Codigo del rol @type id_proyecto : Integer @param id_proyecto : Identificador del proyecto al cual se va aplicar el rol @rtype : Rol @return : El rol que es asignado al usuario. """ #Se obtiene el rol con el nombre correspondiente rol = rol_util.get_by_codigo(cod_rol) #Se verifica si el usuario posee el rol rol_usuario = usuario_util.usuario_has_rol(usuario_id, rol) #si no posee el rol, se le asigna if rol_usuario == None: rol_usuario = RolUsuario() rol_usuario.usuario_id = usuario_id rol_usuario.rol_id = rol.rol_id DBSession.add(rol_usuario) return rol
def importar_este_tipo(self, idtipo, idfase):
"""
Se obtiene de la BD el tipo de item y sus atributos
"""
tipo = DBSession.query(TipoItem).get(idtipo)
atributos = DBSession.query(AtributoTipoItem).\
filter(AtributoTipoItem.tipo_item==tipo.id_tipo_item)
"""
Se settean los valores de la copia
El nuevo tipo de item (copia_tipo )pertenecera a esta fase ahora
"""
copia_tipo = TipoItem()
copia_tipo.nombre = tipo.nombre
copia_tipo.descripcion = tipo.descripcion
copia_tipo.fase = idfase
copia_tipo.codigo = tipo.codigo
'''
Se settean los valores para cada copia_atributo
'''
for atributo in atributos:
copia_atributo = AtributoTipoItem()
copia_atributo.nombre = atributo.nombre
copia_atributo.tipo_id = atributo.tipo_id
copia_tipo.atributos.append(copia_atributo)
DBSession.add(copia_tipo)
flash("El tipo de item "+str(tipo.nombre)+
" pertenece ahora a esta fase")
redirect("/miproyecto/fase/tipo_item/importar/"+str(idfase))
def post_delete(self, *args, **kw):
"""This is the code that actually deletes the record"""
pks = self.provider.get_primary_fields(self.model)
d = {}
for i, arg in enumerate(args):
d[pks[i]] = arg
"""extraer el idFase para poder retornar en el estado anterior """
idfase = DBSession.query(Item.idFase).filter_by(id=d['id']).first()
"""------------------------------------------------------------"""
"""Se crea objeto y cambia de estado """
itemeDelete = DBSession.query(Item).filter_by(id=d['id']).first()
itemeDelete.estado = "borrado"
itemeDelete.ultimaversion = 0
DBSession.add(itemeDelete)
"""---------Se borra las relaciones del Item Borrado--------------"""
relaciones = DBSession.query(
RelacionItem).filter((RelacionItem.idItem1 == d['id'])
| (RelacionItem.idItem2 == d['id'])).all()
longitud = len(relaciones)
for x in range(longitud):
DBSession.delete(relaciones[x])
"""---------------------------------------------------------------"""
#self.provider.delete(self.model, d)
#self.provider.delete(self.model, d)
#redirect('./' + '../' * (len(pks) - 1))
raise redirect('/item/?fid=' + str(idfase[0]))
def post(self, args={}, **kw):
"""
Evento invocado luego de un evento post en el form de crear
ecargado de persistir las nuevas instancias.
@type args : Hash
@param args : Argumentos de template
@type kw : Hash
@param kw : Keywords
"""
del kw['sprox_id']
rol = Rol()
rol.codigo = kw['codigo']
rol.nombre = kw['nombre']
rol.descripcion = kw['descripcion']
for permiso in kw['permisos'] :
rol.permisos.append(DBSession.query(Permiso).get(permiso))
DBSession.add(rol)
flash("El rol ha sido creado correctamente.")
redirect("/administracion/rol/get_all")
def 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
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
def post(self, idfase, args={},**kw):
"""
Evento invocado luego de un evento post en el form de crear
ecargado de persistir las nuevas instancias.
@type idfase : Integer
@param idfase : Identificador de la fase.
@type args : Hash
@param args : Argumentos de template
@type kw : Hash
@param kw : Keywords
"""
del kw['sprox_id']
"""
se crea la nueva relacion y se le asignan los valores de los combos
"""
if kw['item_1'] != None and kw['item_2'] != None:
relacion = RelacionItem()
relacion.id_item_actual = kw['item_1']
relacion.id_item_relacionado = kw['item_2']
relacion.relacion_parentesco = 2
DBSession.merge(relacion)
#auditar items y aumentar su version
item1 = DBSession.query(Item).get(kw['item_1'])
item2 = DBSession.query(Item).get(kw['item_2'])
item_util.audit_item(item1)
item_util.audit_item(item2)
item1.version += 1
item2.version += 1
DBSession.add(item1)
DBSession.add(item2)
#marcar en revision los relacionados
fase = DBSession.query(Fase).get(item1.fase)
grafo = item_util.proyectGraphConstructor(fase.proyecto)
item_util.marcar_en_revision(grafo, item1.id_item)
flash("La relacion se ha creado correctamente")
redirect("/miproyecto/fase/relacion/list/"+idfase)
flash("No se puede crear la relacion", 'warning')
redirect("/miproyecto/fase/relacion/"+idfase+"/new/")
def audit_item(self, item): """ Registra los cambios realizados al item determinado en el historial se persiste los valore del item y su atributos en el historial. @type item : Integer @param item : Identificador del proyecto al cual se va aplicar el rol """ historial = HistorialItem() historial.id_item = item.id_item historial.nombre = item.nombre historial.codigo = item.codigo historial.estado = item.estado historial.tipo_item = item.tipo_item historial.fase = item.fase historial.version = item.version historial.prioridad = item.prioridad historial.complejidad = item.complejidad historial.descripcion = item.descripcion historial.observacion = item.observacion historial.linea_base = item.linea_base #historial de detalles detalles = DBSession.query(DetalleItem).\ filter(DetalleItem.id_item==historial.id_item).\ all() for detalle in detalles: historial_detalle = HistorialDetalleItem() historial_detalle.id_detalle = detalle.id_item_detalle historial_detalle.id_item = detalle.id_item historial_detalle.adjunto = detalle.adjunto historial_detalle.observacion = detalle.observacion historial_detalle.valor = detalle.valor historial.detalles.append(historial_detalle) #Obtener las relaciones relaciones = DBSession.query(RelacionItem).\ filter((RelacionItem.id_item_actual or RelacionItem.id_item_relacionado) == item.id_item).\ all() for relacion in relaciones: historial_relacion = HistorialRelacion() historial_relacion.id_item_1 = relacion.id_item_actual historial_relacion.id_item_2 = relacion.id_item_relacionado historial_relacion.id_tipo_relacion = relacion.relacion_parentesco historial.relaciones.append(historial_relacion) DBSession.add(historial)
def post(self, idproyecto, **kw):
"""
Evento invocado luego de un evento post en el form de crear
ecargado de persistir las nuevas instancias.
@type idproyecto : Integer
@param idproyecto : Identificador del Proyecto.
@type kw : Hash
@param kw : Keywords
"""
del kw['sprox_id']
fase = Fase(**kw)
fase.proyecto = idproyecto
DBSession.add(fase)
redirect("/miproyecto/ver/"+idproyecto)
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']
usuario = Usuario(**kw)
DBSession.add(usuario)
flash("El usuario ha sido creado correctamente.")
redirect("/administracion/usuario/get_all")
def post(self, *args, **kw):
userfile = kw['userfile']
log.debug("kwwww: %s" % kw)
forbidden_files = [".js", ".htm", ".html"]
for forbidden_file in forbidden_files:
if userfile.filename.find(forbidden_file) != -1:
return redirect("/adjuntos/new")
filecontent = userfile.file.read()
new_file = Adjuntos(filename=userfile.filename,
filecontent=filecontent)
DBSession.add(new_file)
DBSession.flush()
redirect("/adjuntos/new")
#self.provider.create(self.model, params=kw)
raise redirect('/adjuntos/new')
def post(self, *args, **kw):
userfile=kw['userfile']
log.debug("kwwww: %s" %kw)
forbidden_files = [".js", ".htm", ".html"]
for forbidden_file in forbidden_files:
if userfile.filename.find(forbidden_file) != -1:
return redirect("/adjuntos/new")
filecontent = userfile.file.read()
new_file = Adjuntos(filename=userfile.filename, filecontent=filecontent)
DBSession.add(new_file)
DBSession.flush()
redirect("/adjuntos/new")
#self.provider.create(self.model, params=kw)
raise redirect('/adjuntos/new')
def put(self, id, **kw):
"""
Evento invocado luego de un evento post en el form de editar
encargado de persistir las modificaciones de las instancias.
@type id : Integer
@param id : Identificador del item.
@type kw : Hash
@param kw : Keywords
"""
kw['id_item'] = id
item = DBSession.query(Item).get(int(kw['id_item']))
item_util.audit_item(item)
archivo = Archivo()
archivo.id_item = id
if kw ['archivo'] != None:
stream = True
archivo.archivo = ""
while stream :
stream = kw ['archivo'].file.read(1024)
archivo.archivo += stream
archivo.file_name = kw ['archivo'].filename
archivo.content_type = kw ['archivo'].type
kw ['archivo'].file.close()
DBSession.add(archivo)
item.version += 1
DBSession.merge(item)
flash("El item atributo ha sido modificado correctamente.")
redirect('/miproyecto/fase/item/poner_en_revision/'+str(archivo.id_item))
def post(self,**kw):
"""
Evento invocado luego de un evento post en el form de crear
ecargado de persistir las nuevas instancias.
@type kw : Hash
@param kw : Keywords
"""
del kw['sprox_id']
kw['lider'] = DBSession.query(Usuario).get(kw['lider'])
kw['estado'] = estado_proyecto_util.get_by_codigo('Inicial')
proyecto = Proyecto(**kw)
#persiste el proyecto
DBSession.add(proyecto)
#Se anhade el rol de lider
proy=DBSession.query(Proyecto).filter(Proyecto.nombre==proyecto.nombre).first()
util.asignar_lider(proy)
flash("El proyecto ha sido creado correctamente.")
redirect("/administracion/proyecto/")
def post(self, idfase, **kw):
"""
Evento invocado luego de un evento post en el form de crear
ecargado de persistir las nuevas instancias.
@type idfase : Integer
@param idfase : Identificador de la fase.
@type kw : Hash
@param kw : Keywords
"""
del kw['sprox_id']
tipo_item = TipoItem(**kw)
codigo = str(tipo_item.codigo)
flag = True
# Se verifica que el codigo del tipo de item sea una secuencia
# de letras mayusculas
for caracter in codigo:
if(not re.match("[A-Z]",caracter)):
flag = False
if(not flag):
flash("El codigo del tipo de item no debe estar conformado solo por letras mayusculas")
redirect('/miproyecto/fase/tipo_item/' + str(idfase) + '/new')
tipo_item.fase = idfase
DBSession.add(tipo_item)
flash("El tipo de Item ha sido creado correctamente")
#traer el ultimo tipo insertado para pasarle su id al formulario de atributos
tipo = DBSession.query(TipoItem).\
filter(TipoItem.nombre==tipo_item.nombre).\
filter(TipoItem.descripcion==tipo_item.descripcion).\
first()
redirect('/miproyecto/fase/tipo_item/atributos/'
+str(tipo.id_tipo_item)+'/new')
def asociar_rol_proyecto(self, cod_rol, proyecto): """ Crea una copia del template de un rol, anhadiendo al nombre del este rol el id de un proyecto. @type cod_rol : String @param cod_rol : Codigo del rol @type proyecto : Proyecto @param proyecto : Proyecto al cual se va aplicar el rol @rtype : Rol @return : El rol que es aplicado al proyecto. """ #Se obtine el rol template rol_template = rol_util.get_by_codigo(cod_rol) if rol_template.is_template == True : rol = self.get_rol_by_codigo(cod_rol+'_'+str(proyecto.id_proyecto)) else: rol= rol_template #Si ya existe el rol para el proyecto if rol != None: return rol #Si no existe el rol para el proyecto lo crea rol = Rol() #cambia el nombre del rol rol.codigo = cod_rol+'_'+str(proyecto.id_proyecto) rol.nombre = rol_template.nombre rol.descripcion = rol_template.descripcion #se periste el rol DBSession.add(rol) #rol = self.get_rol_by_codigo(rol.nombre) #Se obtienen los permisos del template permisos_rol = DBSession.query(Permiso).\ filter(RolPermiso.permiso_id == Permiso.permiso_id).\ filter(RolPermiso.rol_id == rol_template.rol_id) #Anhade a la session el rol para ser persistido rol = rol_util.get_by_codigo(rol.codigo) #Se copian los permisos del template a rol nuevo for permiso in permisos_rol: rol.permisos.append(permiso) rpp = RolPermisoProyecto() rpp.proyecto_id = proyecto.id_proyecto rpp.rol_id = rol.rol_id rpp.permiso_id = permiso.permiso_id #Asocia el rol con los permisos y el proyecto #rol._permisos.append(permiso) DBSession.add(rpp) DBSession.add(rol) #En el caso de que #self.commit_transaction(can_commit) return rol
def post(self, idfase, _method, **kw):
#del kw['sprox_id']
#linea_base = LineaBase(**kw)
lista_codigos = []
dic = kw
for d in dic:
#print 'dddddd = '+ d
lista_codigos.append(d.replace('_', '-'))
lista_items = DBSession.query(Item).filter( Item.codigo.in_(lista_codigos) ).\
all()
linea_base = LineaBase()
linea_base.codigo = linea_base_util.gen_codigo('LB',idfase)
linea_base.estado = estado_linea_base_util.get_by_codigo('Cerrada')
linea_base.fase = idfase
for i in lista_items:
linea_base.items.append(i)
DBSession.add(linea_base)
redirect("/miproyecto/fase/linea_base/list/"+str(idfase))
def post(self, idtipo,args={}, **kw):
"""
Evento invocado luego de un evento post en el form de crear
ecargado de persistir las nuevas instancias.
@type idtipo : Integer
@param idtipo : Identificador del tipo de item.
@type args : Hash
@param args : Argumentos de template
@type kw : Hash
@param kw : Keywords
"""
del kw['sprox_id']
atributo_tipo_item = AtributoTipoItem()
atributo_tipo_item.tipo_item = idtipo
atributo_tipo_item.nombre = kw['nombre']
atributo_tipo_item.tipo_id = kw['tipo']
DBSession.add(atributo_tipo_item)
items = DBSession.query(Item).filter(Item.tipo_item==idtipo)
for item in items :
detalle = DetalleItem()
detalle.nombre = atributo_tipo_item.nombre
detalle.id_atributo_tipo_item = atributo_tipo_item.id_atributo_tipo_item
detalle.valor = None
detalle.recurso = None
item.detalles.append(detalle)
DBSession.merge(item)
DBSession.flush()
flash("El Atributo del tipo de Item ha sido creado correctamente")
redirect('/miproyecto/fase/tipo_item/atributos/'+idtipo+'/new')
def put(self, *args, **kw):
"""update"""
pks = self.provider.get_primary_fields(self.model)
for i, pk in enumerate(pks):
if pk not in kw and i < len(args):
kw[pk] = args[i]
#self.provider.update(self.model, params=kw)
log.debug('detalleEditado: %s' %kw)
detalleitem = DBSession.query(DetalleItem).filter_by(id=kw['id']).first()
if str(detalleitem.tipo).__eq__('integer'):
try:
int(kw['valor'])
except:
flash('\"' + str(detalleitem.nombrecampo) + '\". Debe ingresar un entero', 'error')
redirect('../'+kw['id']+'/edit')
elif str(detalleitem.tipo).__eq__('date'):
"""False = fecha no valida
True = fecha valida"""
if not (self.fechaValida(kw['valor'])):
flash('\"' + str(detalleitem.nombrecampo) + '\" Fecha no valida. Formato: dd/mm/aaaa', 'error')
redirect('../'+kw['id']+'/edit')
else:
if kw['valor'].__eq__(''):
flash('\"' + str(detalleitem.nombrecampo) + '\" no puede ser vacio', 'error')
redirect('../'+kw['id']+'/edit')
"""-----------Se obtiene el ID item a editado-------------"""
iid=DBSession.query(DetalleItem.iditem).filter_by(id=kw[pk]).first()
"""Se crea un nuevo item"""
itemeditado=DBSession.query(Item).filter_by(id=iid).first()
itemnuevo=Item()
itemnuevo.version=itemeditado.version + 1
itemnuevo.idTipoDeItem=itemeditado.idTipoDeItem
itemnuevo.idFase=itemeditado.idFase
itemnuevo.idLineaBase=itemeditado.idLineaBase
itemnuevo.fechaCreacion=itemeditado.fechaCreacion
itemnuevo.nrohistorial=itemeditado.nrohistorial
itemnuevo.ultimaversion=1
itemeditado.ultimaversion=0
itemnuevo.estado='modificado'
itemnuevo.complejidad=itemeditado.complejidad
itemnuevo.nombre=itemeditado.nombre
DBSession.add(itemnuevo)
"""Realiza copia de los valores de los atributos especificos"""
atributoeditado=DBSession.query(DetalleItem).filter_by(iditem=itemeditado.id).all()
for objeto in atributoeditado:
nuevoDetalle=DetalleItem()
nuevoDetalle.tipo=objeto.tipo
nuevoDetalle.nombrecampo=objeto.nombrecampo
if str(objeto.id)==str(kw[pk]):
nuevoDetalle.valor=kw['valor']
else:
nuevoDetalle.valor=objeto.valor
nuevoDetalle.iditem=itemnuevo.id
DBSession.add(nuevoDetalle)
"""Realiza copia de los adjuntos"""
adjuntositemeditado=DBSession.query(Adjuntos).filter_by(idItem=itemeditado.id).all()
for adj in adjuntositemeditado:
itemnuevoadjunto=Adjuntos()
itemnuevoadjunto.idItem=itemnuevo.id
itemnuevoadjunto.filename=adj.filename
itemnuevoadjunto.filecontent=adj.filecontent
DBSession.add(itemnuevoadjunto)
"""Copia las relaciones """
relaciones = DBSession.query(RelacionItem.idItem1,RelacionItem.idItem2).filter((RelacionItem.idItem2==itemeditado.id) | (RelacionItem.idItem1==itemeditado.id)).all()
longitud = len(relaciones)
newRelation=RelacionItem()
for x in range(longitud):
if int(itemeditado.id) == int(relaciones[x][0]):
newRelation.idItem1=int(itemnuevo.id)
newRelation.idItem2=relaciones[x][1]
DBSession.add(newRelation)
#self.provider.create(RelacionItem, params=newRelation)
elif int(itemeditado.id) == int(relaciones[x][1]):
newRelation.idItem1=relaciones[x][0]
newRelation.idItem2=int(itemnuevo.id)
DBSession.add(newRelation)
#detalleitem/?iid=113
redirect('../?iid=' + str(itemnuevo.id) )
def put(self, *args, **kw):
"""update"""
pks = self.provider.get_primary_fields(self.model)
for i, pk in enumerate(pks):
if pk not in kw and i < len(args):
kw[pk] = args[i]
"""Extrae todos los valores del item a modificar, para luego crear un nuevo item"""
valoresItem = DBSession.query(
Item.version, Item.idTipoDeItem, Item.idFase, Item.idLineaBase,
Item.fechaCreacion, Item.nrohistorial,
Item.ultimaversion).filter_by(id=kw['id']).first()
"""Se crea una lista, y se le agrega los valores que tendra el item. """
nuevo = {}
nuevo['version'] = valoresItem[0] + 1
nuevo['idTipoDeItem'] = valoresItem[1]
nuevo['idFase'] = valoresItem[2]
nuevo['idLineaBase'] = valoresItem[3]
nuevo['fechaCreacion'] = str(valoresItem[4])
nuevo['nrohistorial'] = valoresItem[5]
nuevo['ultimaversion'] = valoresItem[6]
nuevo['estado'] = 'modificado'
nuevo['complejidad'] = kw['complejidad']
nuevo['nombre'] = kw['nombre']
itemnuevo = self.provider.create(self.model, params=nuevo)
"""Realiza copia de los valores de los atributos especificos"""
itemeditado = DBSession.query(Item).filter_by(id=kw['id']).first()
atributoeditado = DBSession.query(DetalleItem).filter_by(
iditem=itemeditado.id).all()
for objeto in atributoeditado:
nuevoDetalle = DetalleItem()
nuevoDetalle.tipo = objeto.tipo
nuevoDetalle.nombrecampo = objeto.nombrecampo
nuevoDetalle.valor = objeto.valor
nuevoDetalle.iditem = itemnuevo.id
DBSession.add(nuevoDetalle)
"""Realiza copia de los adjuntos"""
adjuntositemeditado = DBSession.query(Adjuntos).filter_by(
idItem=itemeditado.id).all()
for adj in adjuntositemeditado:
itemnuevoadjunto = Adjuntos()
itemnuevoadjunto.idItem = itemnuevo.id
itemnuevoadjunto.filename = adj.filename
itemnuevoadjunto.filecontent = adj.filecontent
DBSession.add(itemnuevoadjunto)
"""-----------------------------"""
itemeditado = DBSession.query(Item).filter_by(id=kw['id']).first()
itemeditado.ultimaversion = 0
itemnuevo = DBSession.query(Item.id).filter_by(
nrohistorial=nuevo['nrohistorial'], ultimaversion=1).first()
relaciones = DBSession.query(
RelacionItem.idItem1, RelacionItem.idItem2).filter(
(RelacionItem.idItem2 == itemeditado.id)
| (RelacionItem.idItem1 == itemeditado.id)).all()
longitud = len(relaciones)
newRelation = {}
for x in range(longitud):
if int(itemeditado.id) == int(relaciones[x][0]):
newRelation['idItem1'] = int(itemnuevo[0])
newRelation['idItem2'] = relaciones[x][1]
self.provider.create(RelacionItem, params=newRelation)
elif int(itemeditado.id) == int(relaciones[x][1]):
newRelation['idItem1'] = relaciones[x][0]
newRelation['idItem2'] = int(itemnuevo[0])
self.provider.create(RelacionItem, params=newRelation)
ids = []
ids.append(int(itemnuevo[0]))
self.recorrerArbolAtras(ids, int(itemnuevo[0]))
self.recorrerArbolAdelante(ids, int(itemnuevo[0]))
ids.remove(int(itemnuevo[0]))
longitudids = len(ids)
for x in range(longitudids):
itemrevision = DBSession.query(Item).filter_by(
id=ids[x], ultimaversion=1).first()
if itemrevision != None:
if itemrevision.estado != 'modificado':
itemrevision.estado = 'revision'
if itemrevision.idLineaBase != None:
lineabase = DBSession.query(LineaBase).filter_by(
id=itemrevision.idLineaBase).first()
if lineabase.estado == 'cerrada':
lineabase.estado = 'comprometida'
listalineabase = DBSession.query(
LineaBase).filter_by(
idFase=lineabase.idFase).all()
desarrollo = True
longitud = len(listalineabase)
for y in range(longitud):
if str(listalineabase[y].estado).__eq__(
'cerrada'):
desarrollo = False
if desarrollo:
fase = DBSession.query(Fase).filter_by(
id=lineabase.idFase).first()
fase.estado = 'desarrollo'
flash("El item \"" + kw['nombre'] +
"\" ha sido modificado correctamente")
redirect('../' + '../item/?fid=' + str(nuevo['idFase']))
def edit(self, *args, **kw):
"""este codigo es ejecutado cuando se revierte un item """
pks = self.provider.get_primary_fields(self.model)
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
"""-----------Se obtiene el item a revertir -------------"""
item = DBSession.query(Item).filter_by(id=kw['id']).first()
"""------------------------------------------------------"""
"""------obtine el numero de la mayor version del item---"""
versionmayor = DBSession.query(Item.version).filter_by(
nrohistorial=item.nrohistorial, ultimaversion=1).first()
"""------------------------------------------------------"""
""" ---el item con la version mayor, cambia su ultimaversion a cero --- """
item3 = DBSession.query(Item).filter_by(nrohistorial=item.nrohistorial,
ultimaversion=1).first()
log.debug('item3= %s' % item3)
item3.ultimaversion = 0
log.debug("versionmayor= %s" % versionmayor[0])
item2 = Item()
item2.nombre = item.nombre
item2.idTipoDeItem = item.idTipoDeItem
item2.idFase = item.idFase
item2.idLineaBase = item.idLineaBase
"""el item a revertir aumenta su version a la ultima y el
el item con la ultima version, "ultima version" pasa a 0 """
item2.version = versionmayor[0] + 1
item2.ultimaversion = 1
item2.estado = item.estado
item2.complejidad = item.complejidad
item2.fechaCreacion = item.fechaCreacion
item2.nrohistorial = item.nrohistorial
DBSession.add(item2)
"""Realiza copia de los valores de los atributos especificos"""
atributoeditado = DBSession.query(DetalleItem).filter_by(
iditem=item.id).all()
for objeto in atributoeditado:
nuevoDetalle = DetalleItem()
nuevoDetalle.tipo = objeto.tipo
nuevoDetalle.nombrecampo = objeto.nombrecampo
nuevoDetalle.valor = objeto.valor
nuevoDetalle.iditem = item2.id #el ID del nuevo item
DBSession.add(nuevoDetalle)
"""Realiza copia de los adjuntos"""
adjuntositemeditado = DBSession.query(Adjuntos).filter_by(
idItem=item.id).all()
for adj in adjuntositemeditado:
log.debug("adj: %s" % adj)
itemnuevoadjunto = Adjuntos()
itemnuevoadjunto.idItem = item2.id
itemnuevoadjunto.filename = adj.filename
itemnuevoadjunto.filecontent = adj.filecontent
DBSession.add(itemnuevoadjunto)
"""Copia las relaciones """
relaciones = DBSession.query(
RelacionItem.idItem1,
RelacionItem.idItem2).filter((RelacionItem.idItem2 == item.id) | (
RelacionItem.idItem1 == item.id)).all()
longitud = len(relaciones)
for x in range(longitud):
newRelation = RelacionItem()
if int(item.id) == int(relaciones[x][0]):
newRelation.idItem1 = int(item2.id)
newRelation.idItem2 = relaciones[x][1]
DBSession.add(newRelation)
#self.provider.create(RelacionItem, params=newRelation)
elif int(item.id) == int(relaciones[x][1]):
newRelation.idItem1 = relaciones[x][0]
newRelation.idItem2 = int(item2.id)
DBSession.add(newRelation)
redirect('../' + '../item/?fid=' + str(item.idFase))
def post(self, idfase, args={},**kw):
"""
Evento invocado luego de un evento post en el form de crear
ecargado de persistir las nuevas instancias.
@type idfase : Integer
@param idfase : Identificador de la fase.
@type args : Hash
@param args : Argumentos de template
@type kw : Hash
@param kw : Keywords
"""
del kw['sprox_id']
item = Item()
item.nombre = kw['nombre']
item.descripcion = kw['descripcion']
item.complejidad = kw['complejidad']
item.prioridad = kw['prioridad']
item.observacion = kw['observacion']
item.fase = idfase
# Se crea con estado En Desarrollo por defecto
item.estado = 2
item.tipo_item = kw['tipo_item_relacion']
item.version = 1
tipo_item = DBSession.query(TipoItem).get(item.tipo_item)
#anhadir detalles al item segun el tipo de item al cual corresponda
item.detalles = item_util.anadir_detalles(tipo_item)
item.codigo = item_util.gen_cod(idfase, item.tipo_item)
DBSession.add(item)
DBSession.flush()
# Se guarda la relacion elegida en el formulario
if(kw['relaciones'] != None):
relacion = RelacionItem()
#el padre es el item que se selecciono en el combo
relacion.id_item_actual = kw['relaciones']
#el item nuevo es el hijo
relacion.id_item_relacionado = item.id_item
item_relacionado = DBSession.query(Item).get(kw['relaciones'])
#auditar el item
item_util.audit_item(item_relacionado)
item_relacionado.version += 1
DBSession.merge(item_relacionado)
DBSession.flush()
if(item_relacionado.fase == int(idfase)):
#relacion padre-hijo
relacion.relacion_parentesco = 1
else:
relacion.relacion_parentesco = 2
DBSession.add(relacion)
DBSession.flush()
#flash("El item se ha creado correctamente")
redirect('/miproyecto/fase/item/ver/'+str(item.id_item))
def edit(self, *args, **kw):
"""este codigo es ejecutado cuando se revierte un item """
pks = self.provider.get_primary_fields(self.model)
kw = {}
for i, pk in enumerate(pks):
kw[pk] = args[i]
value = self.edit_filler.get_value(kw)
"""-----------Se obtiene el item a revertir -------------"""
item=DBSession.query(Item).filter_by(id=kw['id']).first()
"""------------------------------------------------------"""
"""------obtine el numero de la mayor version del item---"""
versionmayor= DBSession.query(Item.version).filter_by(nrohistorial=item.nrohistorial ,ultimaversion=1).first()
"""------------------------------------------------------"""
""" ---el item con la version mayor, cambia su ultimaversion a cero --- """
item3=DBSession.query(Item).filter_by(nrohistorial=item.nrohistorial,ultimaversion=1).first()
log.debug('item3= %s'%item3 )
item3.ultimaversion=0
log.debug("versionmayor= %s" %versionmayor[0])
item2=Item()
item2.nombre=item.nombre
item2.idTipoDeItem=item.idTipoDeItem
item2.idFase=item.idFase
item2.idLineaBase=item.idLineaBase
"""el item a revertir aumenta su version a la ultima y el
el item con la ultima version, "ultima version" pasa a 0 """
item2.version= versionmayor[0]+1
item2.ultimaversion=1
item2.estado=item.estado
item2.complejidad=item.complejidad
item2.fechaCreacion=item.fechaCreacion
item2.nrohistorial=item.nrohistorial
DBSession.add(item2)
"""Realiza copia de los valores de los atributos especificos"""
atributoeditado=DBSession.query(DetalleItem).filter_by(iditem=item.id).all()
for objeto in atributoeditado:
nuevoDetalle=DetalleItem()
nuevoDetalle.tipo=objeto.tipo
nuevoDetalle.nombrecampo=objeto.nombrecampo
nuevoDetalle.valor=objeto.valor
nuevoDetalle.iditem=item2.id #el ID del nuevo item
DBSession.add(nuevoDetalle)
"""Realiza copia de los adjuntos"""
adjuntositemeditado=DBSession.query(Adjuntos).filter_by(idItem=item.id).all()
for adj in adjuntositemeditado:
log.debug("adj: %s" %adj)
itemnuevoadjunto=Adjuntos()
itemnuevoadjunto.idItem=item2.id
itemnuevoadjunto.filename=adj.filename
itemnuevoadjunto.filecontent=adj.filecontent
DBSession.add(itemnuevoadjunto)
"""Copia las relaciones """
relaciones = DBSession.query(RelacionItem.idItem1,RelacionItem.idItem2).filter((RelacionItem.idItem2==item.id) | (RelacionItem.idItem1==item.id)).all()
longitud = len(relaciones)
for x in range(longitud):
newRelation=RelacionItem()
if int(item.id) == int(relaciones[x][0]):
newRelation.idItem1=int(item2.id)
newRelation.idItem2=relaciones[x][1]
DBSession.add(newRelation)
#self.provider.create(RelacionItem, params=newRelation)
elif int(item.id) == int(relaciones[x][1]):
newRelation.idItem1=relaciones[x][0]
newRelation.idItem2=int(item2.id)
DBSession.add(newRelation)
redirect('../'+'../item/?fid=' + str(item.idFase))
def revertir_item (self, historial_item):
"""
Dada una entidad HistorialItem que representa una version
anterior del item en si se obtiene de la tabla las entradas de
esa version para que el item recupere los valores de esa version
"""
#debe ser una version posterior a la actual
item = DBSession.query(Item).get(historial_item.id_item)
detalles = item.detalles
print "Recuperar el item "+str(item)
item.nombre = historial_item.nombre
item.codigo = historial_item.codigo
item.estado_actual = estado_item_util.get_by_codigo('Revision')
#item.estado = item.estado_actual.id_estado_item
item.tipo_item = historial_item.tipo_item
item.fase = historial_item.fase
item.version += 1
item.prioridad = historial_item.prioridad
item.complejidad = historial_item.complejidad
item.descripcion = historial_item.descripcion
item.observacion = historial_item.observacion
item.linea_base = None
#Se borran todos los archivos
print "Borrando todos los archivos acutales"
for archivo in item.archivos :
DBSession.delete(archivo)
#Se reestauran todos los arachivos
item.archivos = []
DBSession.merge(item)
print "Anhadiendo nuevos archivos."
for archivo in historial_item.archivos :
print "archivo: "+ str(archivo)
new_archivo = Archivo()
new_archivo.archivo = archivo.archivo
new_archivo.file_name = archivo.file_name
new_archivo.content_type = archivo.content_type
new_archivo.id_item = item.id_item
DBSession.add(new_archivo)
print "Recuperar los detalles"
#recuperar los detalles
historial_detalles = DBSession.query(HistorialDetalleItem).\
filter(HistorialDetalleItem.id_historial == historial_item.id_historial_item).\
all()
#variable para indexar las posiciones que corresponden a los valores
#de esa version
atributo_mapper = {}
index = 0
"""
Se establecen los detalles actuales del item a None
para que el item conserve los campos definidos por su tipo de
item. El item recuperara los valores de la version a la cual se
quiere revertir
"""
for detalle in item.detalles:
detalle.valor = None
detalle.observacion = None
atributo_mapper[detalle.id_atributo_tipo_item] = index
index += 1
for hist_detalle in historial_detalles:
index = atributo_mapper[hist_detalle.id_atributo_tipo_item]
item.detalles[index].observacion = hist_detalle.observacion
item.detalles[index].valor = hist_detalle.valor
DBSession.merge(item)
#borrar las relaciones actuales
relaciones = DBSession.query(RelacionItem).\
filter(or_(RelacionItem.id_item_actual == item.id_item,
RelacionItem.id_item_relacionado == item.id_item)).\
all()
print relaciones
for relacion in relaciones:
#se verifica que no deje huerfanos
if not self.deja_huerfanos(relacion):
print 'borrando relacion'
DBSession.delete(relacion)
print "Recuperar las relaciones"
#recuperar los relaciones
historial_relaciones = DBSession.query(HistorialRelacion).\
filter(HistorialRelacion.id_item_1 == item.id_item or
HistorialRelacion.id_item_2 == item.id_item).\
all()
print historial_relaciones
for hist_relacion in historial_relaciones:
relacion = RelacionItem()
if(DBSession.query(Item).get(hist_relacion.id_item_1)!=None and
DBSession.query(Item).get(hist_relacion.id_item_2)!=None):
relacion.id_item_actual = hist_relacion.id_item_1
relacion.id_item_relacionado = hist_relacion.id_item_2
relacion.relacion_parentesco = hist_relacion.id_tipo_relacion
DBSession.merge(relacion)
print "Merge"
DBSession.merge(item)
print "Flush"
DBSession.flush()
return
def audit_item(self, item): """ Registra los cambios realizados al item determinado en el historial se persiste los valore del item y su atributos en el historial. @type item : Integer @param item : Identificador del proyecto al cual se va aplicar el rol """ historial = HistorialItem() historial.id_item = item.id_item historial.nombre = item.nombre historial.codigo = item.codigo historial.estado = item.estado historial.tipo_item = item.tipo_item historial.fase = item.fase historial.version = item.version historial.prioridad = item.prioridad historial.complejidad = item.complejidad historial.descripcion = item.descripcion historial.observacion = item.observacion #~ #historial de detalles #~ detalles = DBSession.query(DetalleItem).\ #~ filter(DetalleItem.id_item==item.id_item).\ #~ all() for archivo in item.archivos : historial_archivo = HistorialArchivo() historial_archivo.archivo = archivo.archivo historial_archivo.file_name = archivo.file_name historial_archivo.content_type = archivo.content_type historial_archivo.id_historial = historial.id_historial_item historial_archivo.id_item = archivo.id_item historial.archivos.append(historial_archivo) for detalle in item.detalles: historial_detalle = HistorialDetalleItem() historial_detalle.id_detalle = detalle.id_item_detalle historial_detalle.id_atributo_tipo_item = detalle.id_atributo_tipo_item historial_detalle.id_item = detalle.id_item historial_detalle.observacion = detalle.observacion historial_detalle.valor = detalle.valor historial.detalles.append(historial_detalle) #Obtener las relaciones relaciones = DBSession.query(RelacionItem).\ filter(or_(RelacionItem.id_item_actual == item.id_item, RelacionItem.id_item_relacionado == item.id_item)).\ all() print relaciones for relacion in relaciones: historial_relacion = HistorialRelacion() historial_relacion.id_item_1 = relacion.id_item_actual historial_relacion.id_item_2 = relacion.id_item_relacionado historial_relacion.id_tipo_relacion = relacion.relacion_parentesco historial.relaciones.append(historial_relacion) DBSession.add(historial) DBSession.flush()
def new(self, iid=None, *args, **kw):
"""Aqui entra solo para mostrar la vista y para guardar, el descargar
borrar esta implementado en root"""
log.debug('iid: %s' % iid)
log.debug('adjuntos: %s' % kw)
longitud = len(kw)
log.debug('longitud: %s' % longitud)
if longitud == 0:
#current_files = DBSession.query(Adjuntos).all()
current_files = DBSession.query(Adjuntos).filter_by(
idItem=iid).all()
return dict(current_files=current_files,
model=self.model.__name__,
iid=iid)
else:
if iid == "save":
iid = kw['idItem']
idItem = kw['idItem']
userfile = kw['userfile']
log.debug('idItem: %s' % idItem)
if userfile == '':
flash("No ha selecionado ningun archivo", "error")
redirect("../new/?iid=" + str(iid))
"""
forbidden_files = [".js", ".htm", ".html"]
for forbidden_file in forbidden_files:
if userfile.filename.find(forbidden_file) != -1:
return redirect("../adjuntos/new")
filecontent = userfile.file.read()
new_file = Adjuntos(filename=userfile.filename, filecontent=filecontent,idItem=idItem )
DBSession.add(new_file)
DBSession.flush()
"""
"""Realiza una copia del item cuando se adjunta un archivo y aumenta su version"""
itemeditado = DBSession.query(Item).filter_by(id=idItem).first()
itemnuevo = Item()
itemnuevo.version = itemeditado.version + 1
itemnuevo.idTipoDeItem = itemeditado.idTipoDeItem
itemnuevo.idFase = itemeditado.idFase
itemnuevo.idLineaBase = itemeditado.idLineaBase
itemnuevo.fechaCreacion = itemeditado.fechaCreacion
itemnuevo.nrohistorial = itemeditado.nrohistorial
itemnuevo.ultimaversion = 1
itemeditado.ultimaversion = 0
itemnuevo.estado = 'modificado'
itemnuevo.complejidad = itemeditado.complejidad
itemnuevo.nombre = itemeditado.nombre
DBSession.add(itemnuevo)
"""Realiza copia de los valores de los atributos especificos"""
atributoeditado = DBSession.query(DetalleItem).filter_by(
iditem=itemeditado.id).all()
for objeto in atributoeditado:
nuevoDetalle = DetalleItem()
nuevoDetalle.tipo = objeto.tipo
nuevoDetalle.nombrecampo = objeto.nombrecampo
nuevoDetalle.valor = objeto.valor
nuevoDetalle.iditem = itemnuevo.id
DBSession.add(nuevoDetalle)
"""Copia las relaciones """
relaciones = DBSession.query(
RelacionItem.idItem1, RelacionItem.idItem2).filter(
(RelacionItem.idItem2 == itemeditado.id)
| (RelacionItem.idItem1 == itemeditado.id)).all()
longitud = len(relaciones)
for x in range(longitud):
newRelation = RelacionItem()
log.debug('Creando relaciones')
if int(itemeditado.id) == int(relaciones[x][0]):
newRelation.idItem1 = int(itemnuevo.id)
newRelation.idItem2 = relaciones[x][1]
DBSession.add(newRelation)
#self.provider.create(RelacionItem, params=newRelation)
elif int(itemeditado.id) == int(relaciones[x][1]):
newRelation.idItem1 = relaciones[x][0]
newRelation.idItem2 = int(itemnuevo.id)
DBSession.add(newRelation)
"""Realiza copia de los adjuntos"""
adjuntositemeditado = DBSession.query(Adjuntos).filter_by(
idItem=itemeditado.id).all()
for adj in adjuntositemeditado:
itemnuevoadjunto = Adjuntos()
log.debug("adj: %s" % adj)
itemnuevoadjunto = Adjuntos()
itemnuevoadjunto.idItem = itemnuevo.id
itemnuevoadjunto.filename = adj.filename
itemnuevoadjunto.filecontent = adj.filecontent
DBSession.add(itemnuevoadjunto)
forbidden_files = [".js", ".htm", ".html"]
for forbidden_file in forbidden_files:
if userfile.filename.find(forbidden_file) != -1:
return redirect("../adjuntos/new")
filecontent = userfile.file.read()
log.debug('itemnuevo: %s' % itemnuevo.id)
new_file = Adjuntos(filename=userfile.filename,
filecontent=filecontent,
idItem=itemnuevo.id)
DBSession.add(new_file)
#DBSession.flush()
#self.provider.create(self.model, params=nuevo)
log.debug('adjuntositemeditado: %s' % adjuntositemeditado)
redirect("../new/?iid=" + str(itemnuevo.id))
def put(self, id_item, **kw):
item = DBSession.query(Item).get(id_item)
# Se registra en el historial el item antes de ser modificado
item_util.audit_item(item)
# Se modifica el item
item.descripcion = kw['descripcion']
#item.codigo = kw['codigo']
item.nombre = kw['nombre']
item.complejidad = kw['complejidad']
item.prioridad = kw['prioridad']
item.observacion = kw['observacion']
item.version = int(item.version) + 1
item.estado = 2 # En Desarrollo
#Se persiste el item
DBSession.merge(item)
DBSession.flush()
#se verifica si ya tenia un padre
relacion = DBSession.query(RelacionItem).\
filter(RelacionItem.id_item_relacionado==item.id_item).\
filter(RelacionItem.relacion_parentesco==1).\
all()
#se borra las relacion padre hijo si existia
if relacion != []:
DBSession.delete(relacion[0])
# Si se elijio NONE en las relaciones no se hace nada
if(kw['relaciones'] != None):
item_padre_antecesor = DBSession.query(Item).get(kw['relaciones'])
item_util.audit_item(item_padre_antecesor)
item_padre_antecesor.version += 1
DBSession.merge(item_padre_antecesor)
DBSession.flush()
#tipo de relacion 1 padre-hijo, 2 antecesor sucesor
tipo_relacion = 2
if item_padre_antecesor.fase == int(item.fase):
tipo_relacion = 1
rel = RelacionItem()
rel.relacion_parentesco = tipo_relacion
rel.id_item_actual = kw['relaciones']
rel.id_item_relacionado = item.id_item
DBSession.add(rel)
DBSession.flush()
fase = DBSession.query(Fase).get(item.fase)
grafo = item_util.proyectGraphConstructor(fase.proyecto)
item_util.marcar_en_revision(grafo, item.id_item)
#la linea del item modificado permanece abierta
if item.linea_base != None:
linea = item.linea_base
linea.estado = estado_linea_base_util.get_by_codigo('Abierta')
flash("El item " +str(item.nombre)+ " ha sido modificado correctamente.")
redirect('/miproyecto/fase/item/ver/'+str(item.id_item))
def post(self, *args, **kw):
"""Se crea un nuevo item"""
itemeditado=DBSession.query(Item).filter_by(id=kw['idItem1']).first()
itemnuevo=Item()
itemnuevo.version=itemeditado.version + 1
itemnuevo.idTipoDeItem=itemeditado.idTipoDeItem
itemnuevo.idFase=itemeditado.idFase
itemnuevo.idLineaBase=itemeditado.idLineaBase
itemnuevo.fechaCreacion=itemeditado.fechaCreacion
itemnuevo.nrohistorial=itemeditado.nrohistorial
itemnuevo.ultimaversion=1
itemeditado.ultimaversion=0
itemnuevo.estado='modificado'
itemnuevo.complejidad=itemeditado.complejidad
itemnuevo.nombre=itemeditado.nombre
DBSession.add(itemnuevo)
DBSession.flush()
"""-------------------------"""
""" Crea las nuevas relaciones"""
kw['idItem1']=itemnuevo.id
""" Se crea las relaciones"""
ids=kw['idItem2']
longitud=len(kw['idItem2'])
for indice in range(longitud):
kw['idItem2']=ids[indice]
self.provider.create(self.model, params=kw)
ids=kw['idItem2Anterior']
longitud=len(kw['idItem2Anterior'])
for indice in range(longitud):
kw['idItem2']=ids[indice]
self.provider.create(self.model, params=kw)
"""Realiza copia de los valores de los atributos especificos"""
atributoeditado=DBSession.query(DetalleItem).filter_by(iditem=itemeditado.id).all()
for objeto in atributoeditado:
nuevoDetalle=DetalleItem()
nuevoDetalle.tipo=objeto.tipo
nuevoDetalle.nombrecampo=objeto.nombrecampo
nuevoDetalle.valor=objeto.valor
nuevoDetalle.iditem=itemnuevo.id
DBSession.add(nuevoDetalle)
"""Realiza copia de los adjuntos"""
adjuntositemeditado=DBSession.query(Adjuntos).filter_by(idItem=itemeditado.id).all()
for adj in adjuntositemeditado:
itemnuevoadjunto=Adjuntos()
itemnuevoadjunto.idItem=itemnuevo.id
itemnuevoadjunto.filename=adj.filename
itemnuevoadjunto.filecontent=adj.filecontent
DBSession.add(itemnuevoadjunto)
"""Copia las relaciones """
#itemnuevo=DBSession.query(Item.id).filter_by(nrohistorial=nuevo['nrohistorial'], ultimaversion=1).first()
relaciones = DBSession.query(RelacionItem.idItem1,RelacionItem.idItem2).filter((RelacionItem.idItem2==itemeditado.id) | (RelacionItem.idItem1==itemeditado.id)).all()
longitud = len(relaciones)
for x in range(longitud):
newRelation = {}
if int(itemeditado.id) == int(relaciones[x][0]):
newRelation['idItem1']=int(itemnuevo.id)
newRelation['idItem2']=relaciones[x][1]
self.provider.create(RelacionItem, params=newRelation)
elif int(itemeditado.id) == int(relaciones[x][1]):
newRelation['idItem1']=relaciones[x][0]
newRelation['idItem2']=int(itemnuevo.id)
self.provider.create(RelacionItem, params=newRelation)
raise redirect('./?iid='+str(kw['idItem1']))
def new(self,fid=None ,*args, **kw):
"""Display a page to show a new record."""
tmpl_context.widget = self.new_form
log.debug('kwwwwnew: %s' %kw)
longitud=len(kw)
if longitud==0:
tiposdeitems=DBSession.query(TipoDeItem.id,TipoDeItem.nombre).filter(TipoDeItem.idFase != fid).all()
return dict(value={"fid": fid}, model=self.model.__name__ ,importar_options=tiposdeitems)
else:
ids= kw['TiposDeItemImportar']
log.debug('ids: %s' %ids)
longitud= len(ids)
for indice in range(longitud):
"""Hace una copia del tipo de item cambiando el idFase """
idTipo= ids[indice]
tipo=DBSession.query(TipoDeItem).filter_by(id=idTipo).first()
log.debug('tiposss: %s' %tipo)
tipocopia=TipoDeItem()
tipocopia.nombre=tipo.nombre
tipocopia.descripcion=tipo.descripcion
log.debug('tipocopia: %s' %tipocopia)
tipocopia.idFase=fid
DBSession.add(tipocopia) #NuevoTipoItem es el nuevo objeto guardado
NuevoTipoItem=DBSession.query(TipoDeItem.id).filter_by(nombre=tipocopia.nombre, descripcion=tipocopia.descripcion, idFase=fid).first()
#Se copia los los atributos especificos del tipo de item
campos=DBSession.query(Campos).filter_by(idTipoDeItem=idTipo).all()
log.debug(campos)
long2=len(campos)
log.debug("long2: %s" %long2)
for x in range(long2):
#se copia los campos pertenecientes al tipo de item pero con "idTipoDeItem" distinto
log.debug("forrrr: %s" %x)
campocopia=Campos()
campocopia.nombre=campos[x].nombre
campocopia.tipoDeDato=campos[x].tipoDeDato
campocopia.idTipoDeItem=NuevoTipoItem.id
DBSession.add(campocopia)
pid=DBSession.query(Fase.idproyec).filter_by(id=fid).first()
redirect("../../fase/?pid="+ str(pid[0]))
"""ids= kw['idFase']
def delete(self, fileid):
#log.debug("Soy Archivo Borrado")
"""Se extrae el ID del Item que supuestamente se borrará, para crear un nuevo Item """
iid = DBSession.query(Adjuntos.idItem).filter_by(id=fileid).first()
"""Se crea un nuevo item"""
itemeditado = DBSession.query(Item).filter_by(id=iid).first()
itemnuevo = Item()
itemnuevo.version = itemeditado.version + 1
itemnuevo.idTipoDeItem = itemeditado.idTipoDeItem
itemnuevo.idFase = itemeditado.idFase
itemnuevo.idLineaBase = itemeditado.idLineaBase
itemnuevo.fechaCreacion = itemeditado.fechaCreacion
itemnuevo.nrohistorial = itemeditado.nrohistorial
itemnuevo.ultimaversion = 1
itemeditado.ultimaversion = 0
itemnuevo.estado = 'modificado'
itemnuevo.complejidad = itemeditado.complejidad
itemnuevo.nombre = itemeditado.nombre
DBSession.add(itemnuevo)
"""Realiza copia de los valores de los atributos especificos"""
atributoeditado = DBSession.query(DetalleItem).filter_by(
iditem=itemeditado.id).all()
for objeto in atributoeditado:
nuevoDetalle = DetalleItem()
nuevoDetalle.tipo = objeto.tipo
nuevoDetalle.nombrecampo = objeto.nombrecampo
nuevoDetalle.valor = objeto.valor
nuevoDetalle.iditem = itemnuevo.id
DBSession.add(nuevoDetalle)
"""Realiza copia de los adjuntos"""
adjuntositemeditado = DBSession.query(Adjuntos).filter_by(
idItem=itemeditado.id).all()
for adj in adjuntositemeditado:
log.debug("adjuntoBorraado: %s" % adj.id)
log.debug("fileid: %s" % fileid)
if str(adj.id) != str(
fileid): #No se copiará el archivo "supuestamente" borrado
log.debug("fileid2: %s" % fileid)
itemnuevoadjunto = Adjuntos()
itemnuevoadjunto.idItem = itemnuevo.id
itemnuevoadjunto.filename = adj.filename
itemnuevoadjunto.filecontent = adj.filecontent
DBSession.add(itemnuevoadjunto)
"""Copia las relaciones """
relaciones = DBSession.query(
RelacionItem.idItem1, RelacionItem.idItem2).filter(
(RelacionItem.idItem2 == itemeditado.id)
| (RelacionItem.idItem1 == itemeditado.id)).all()
longitud = len(relaciones)
for x in range(longitud):
newRelation = RelacionItem()
log.debug('Creando relaciones')
if int(itemeditado.id) == int(relaciones[x][0]):
newRelation.idItem1 = int(itemnuevo.id)
newRelation.idItem2 = relaciones[x][1]
DBSession.add(newRelation)
#self.provider.create(RelacionItem, params=newRelation)
elif int(itemeditado.id) == int(relaciones[x][1]):
newRelation.idItem1 = relaciones[x][0]
newRelation.idItem2 = int(itemnuevo.id)
DBSession.add(newRelation)
return redirect("../../adjuntos/new/?iid=" + str(itemnuevo.id))
def new(self,iid=None ,*args, **kw):
"""Aqui entra solo para mostrar la vista y para guardar, el descargar
borrar esta implementado en root"""
log.debug('iid: %s' %iid)
log.debug('adjuntos: %s' %kw)
longitud=len(kw)
log.debug('longitud: %s' %longitud)
if longitud==0:
#current_files = DBSession.query(Adjuntos).all()
current_files = DBSession.query(Adjuntos).filter_by(idItem=iid).all()
return dict(current_files=current_files, model=self.model.__name__,iid=iid)
else:
if iid=="save":
iid=kw['idItem']
idItem=kw['idItem']
userfile=kw['userfile']
log.debug('idItem: %s' %idItem)
if userfile=='':
flash("No ha selecionado ningun archivo", "error")
redirect("../new/?iid="+str(iid))
"""
forbidden_files = [".js", ".htm", ".html"]
for forbidden_file in forbidden_files:
if userfile.filename.find(forbidden_file) != -1:
return redirect("../adjuntos/new")
filecontent = userfile.file.read()
new_file = Adjuntos(filename=userfile.filename, filecontent=filecontent,idItem=idItem )
DBSession.add(new_file)
DBSession.flush()
"""
"""Realiza una copia del item cuando se adjunta un archivo y aumenta su version"""
itemeditado= DBSession.query(Item).filter_by(id=idItem).first()
itemnuevo=Item()
itemnuevo.version=itemeditado.version + 1
itemnuevo.idTipoDeItem=itemeditado.idTipoDeItem
itemnuevo.idFase=itemeditado.idFase
itemnuevo.idLineaBase=itemeditado.idLineaBase
itemnuevo.fechaCreacion=itemeditado.fechaCreacion
itemnuevo.nrohistorial=itemeditado.nrohistorial
itemnuevo.ultimaversion=1
itemeditado.ultimaversion=0
itemnuevo.estado='modificado'
itemnuevo.complejidad=itemeditado.complejidad
itemnuevo.nombre=itemeditado.nombre
DBSession.add(itemnuevo)
"""Realiza copia de los valores de los atributos especificos"""
atributoeditado=DBSession.query(DetalleItem).filter_by(iditem=itemeditado.id).all()
for objeto in atributoeditado:
nuevoDetalle=DetalleItem()
nuevoDetalle.tipo=objeto.tipo
nuevoDetalle.nombrecampo=objeto.nombrecampo
nuevoDetalle.valor=objeto.valor
nuevoDetalle.iditem=itemnuevo.id
DBSession.add(nuevoDetalle)
"""Copia las relaciones """
relaciones = DBSession.query(RelacionItem.idItem1,RelacionItem.idItem2).filter((RelacionItem.idItem2==itemeditado.id) | (RelacionItem.idItem1==itemeditado.id)).all()
longitud = len(relaciones)
for x in range(longitud):
newRelation=RelacionItem()
log.debug('Creando relaciones')
if int(itemeditado.id) == int(relaciones[x][0]):
newRelation.idItem1=int(itemnuevo.id)
newRelation.idItem2=relaciones[x][1]
DBSession.add(newRelation)
#self.provider.create(RelacionItem, params=newRelation)
elif int(itemeditado.id) == int(relaciones[x][1]):
newRelation.idItem1=relaciones[x][0]
newRelation.idItem2=int(itemnuevo.id)
DBSession.add(newRelation)
"""Realiza copia de los adjuntos"""
adjuntositemeditado=DBSession.query(Adjuntos).filter_by(idItem=itemeditado.id).all()
for adj in adjuntositemeditado:
itemnuevoadjunto=Adjuntos()
log.debug("adj: %s" %adj)
itemnuevoadjunto=Adjuntos()
itemnuevoadjunto.idItem=itemnuevo.id
itemnuevoadjunto.filename=adj.filename
itemnuevoadjunto.filecontent=adj.filecontent
DBSession.add(itemnuevoadjunto)
forbidden_files = [".js", ".htm", ".html"]
for forbidden_file in forbidden_files:
if userfile.filename.find(forbidden_file) != -1:
return redirect("../adjuntos/new")
filecontent = userfile.file.read()
log.debug('itemnuevo: %s' %itemnuevo.id)
new_file = Adjuntos(filename=userfile.filename, filecontent=filecontent,idItem=itemnuevo.id )
DBSession.add(new_file)
#DBSession.flush()
#self.provider.create(self.model, params=nuevo)
log.debug('adjuntositemeditado: %s' %adjuntositemeditado)
redirect("../new/?iid="+str(itemnuevo.id))
def put(self, *args, **kw):
"""update"""
pks = self.provider.get_primary_fields(self.model)
for i, pk in enumerate(pks):
if pk not in kw and i < len(args):
kw[pk] = args[i]
"""Extrae todos los valores del item a modificar, para luego crear un nuevo item"""
valoresItem=DBSession.query(Item.version ,Item.idTipoDeItem ,Item.idFase ,Item.idLineaBase ,Item.fechaCreacion ,Item.nrohistorial,Item.ultimaversion).filter_by(id=kw['id']).first()
"""Se crea una lista, y se le agrega los valores que tendra el item. """
nuevo={}
nuevo['version']=valoresItem[0]+1
nuevo['idTipoDeItem']=valoresItem[1]
nuevo['idFase']=valoresItem[2]
nuevo['idLineaBase']=valoresItem[3]
nuevo['fechaCreacion']=str(valoresItem[4])
nuevo['nrohistorial']=valoresItem[5]
nuevo['ultimaversion']=valoresItem[6]
nuevo['estado']='modificado'
nuevo['complejidad']=kw['complejidad']
nuevo['nombre']=kw['nombre']
itemnuevo=self.provider.create(self.model, params=nuevo)
"""Realiza copia de los valores de los atributos especificos"""
itemeditado=DBSession.query(Item).filter_by(id=kw['id']).first()
atributoeditado=DBSession.query(DetalleItem).filter_by(iditem=itemeditado.id).all()
for objeto in atributoeditado:
nuevoDetalle=DetalleItem()
nuevoDetalle.tipo=objeto.tipo
nuevoDetalle.nombrecampo=objeto.nombrecampo
nuevoDetalle.valor=objeto.valor
nuevoDetalle.iditem=itemnuevo.id
DBSession.add(nuevoDetalle)
"""Realiza copia de los adjuntos"""
adjuntositemeditado=DBSession.query(Adjuntos).filter_by(idItem=itemeditado.id).all()
for adj in adjuntositemeditado:
itemnuevoadjunto=Adjuntos()
itemnuevoadjunto.idItem=itemnuevo.id
itemnuevoadjunto.filename=adj.filename
itemnuevoadjunto.filecontent=adj.filecontent
DBSession.add(itemnuevoadjunto)
"""-----------------------------"""
itemeditado=DBSession.query(Item).filter_by(id=kw['id']).first()
itemeditado.ultimaversion=0
itemnuevo=DBSession.query(Item.id).filter_by(nrohistorial=nuevo['nrohistorial'], ultimaversion=1).first()
relaciones = DBSession.query(RelacionItem.idItem1,RelacionItem.idItem2).filter((RelacionItem.idItem2==itemeditado.id) | (RelacionItem.idItem1==itemeditado.id)).all()
longitud = len(relaciones)
newRelation = {}
for x in range(longitud):
if int(itemeditado.id) == int(relaciones[x][0]):
newRelation['idItem1']=int(itemnuevo[0])
newRelation['idItem2']=relaciones[x][1]
self.provider.create(RelacionItem, params=newRelation)
elif int(itemeditado.id) == int(relaciones[x][1]):
newRelation['idItem1']=relaciones[x][0]
newRelation['idItem2']=int(itemnuevo[0])
self.provider.create(RelacionItem, params=newRelation)
ids=[]
ids.append(int(itemnuevo[0]))
self.recorrerArbolAtras(ids, int(itemnuevo[0]))
self.recorrerArbolAdelante(ids, int(itemnuevo[0]))
ids.remove(int(itemnuevo[0]))
longitudids = len(ids)
for x in range(longitudids):
itemrevision = DBSession.query(Item).filter_by(id=ids[x], ultimaversion=1).first()
if itemrevision != None:
if itemrevision.estado != 'modificado':
itemrevision.estado = 'revision'
if itemrevision.idLineaBase != None:
lineabase = DBSession.query(LineaBase).filter_by(id=itemrevision.idLineaBase).first()
if lineabase.estado == 'cerrada':
lineabase.estado = 'comprometida'
listalineabase = DBSession.query(LineaBase).filter_by(idFase = lineabase.idFase).all()
desarrollo = True
longitud = len(listalineabase)
for y in range (longitud):
if str(listalineabase[y].estado).__eq__('cerrada'):
desarrollo = False
if desarrollo:
fase = DBSession.query(Fase).filter_by(id = lineabase.idFase).first()
fase.estado = 'desarrollo'
flash("El item \"" +kw['nombre'] +"\" ha sido modificado correctamente")
redirect('../' +'../item/?fid=' + str(nuevo['idFase']))
def post(self, *args, **kw):
"""Se crea un nuevo item"""
itemeditado = DBSession.query(Item).filter_by(id=kw['idItem1']).first()
itemnuevo = Item()
itemnuevo.version = itemeditado.version + 1
itemnuevo.idTipoDeItem = itemeditado.idTipoDeItem
itemnuevo.idFase = itemeditado.idFase
itemnuevo.idLineaBase = itemeditado.idLineaBase
itemnuevo.fechaCreacion = itemeditado.fechaCreacion
itemnuevo.nrohistorial = itemeditado.nrohistorial
itemnuevo.ultimaversion = 1
itemeditado.ultimaversion = 0
itemnuevo.estado = 'modificado'
itemnuevo.complejidad = itemeditado.complejidad
itemnuevo.nombre = itemeditado.nombre
DBSession.add(itemnuevo)
DBSession.flush()
"""-------------------------"""
""" Crea las nuevas relaciones"""
kw['idItem1'] = itemnuevo.id
""" Se crea las relaciones"""
ids = kw['idItem2']
longitud = len(kw['idItem2'])
for indice in range(longitud):
kw['idItem2'] = ids[indice]
self.provider.create(self.model, params=kw)
ids = kw['idItem2Anterior']
longitud = len(kw['idItem2Anterior'])
for indice in range(longitud):
kw['idItem2'] = ids[indice]
self.provider.create(self.model, params=kw)
"""Realiza copia de los valores de los atributos especificos"""
atributoeditado = DBSession.query(DetalleItem).filter_by(
iditem=itemeditado.id).all()
for objeto in atributoeditado:
nuevoDetalle = DetalleItem()
nuevoDetalle.tipo = objeto.tipo
nuevoDetalle.nombrecampo = objeto.nombrecampo
nuevoDetalle.valor = objeto.valor
nuevoDetalle.iditem = itemnuevo.id
DBSession.add(nuevoDetalle)
"""Realiza copia de los adjuntos"""
adjuntositemeditado = DBSession.query(Adjuntos).filter_by(
idItem=itemeditado.id).all()
for adj in adjuntositemeditado:
itemnuevoadjunto = Adjuntos()
itemnuevoadjunto.idItem = itemnuevo.id
itemnuevoadjunto.filename = adj.filename
itemnuevoadjunto.filecontent = adj.filecontent
DBSession.add(itemnuevoadjunto)
"""Copia las relaciones """
#itemnuevo=DBSession.query(Item.id).filter_by(nrohistorial=nuevo['nrohistorial'], ultimaversion=1).first()
relaciones = DBSession.query(
RelacionItem.idItem1, RelacionItem.idItem2).filter(
(RelacionItem.idItem2 == itemeditado.id)
| (RelacionItem.idItem1 == itemeditado.id)).all()
longitud = len(relaciones)
for x in range(longitud):
newRelation = {}
if int(itemeditado.id) == int(relaciones[x][0]):
newRelation['idItem1'] = int(itemnuevo.id)
newRelation['idItem2'] = relaciones[x][1]
self.provider.create(RelacionItem, params=newRelation)
elif int(itemeditado.id) == int(relaciones[x][1]):
newRelation['idItem1'] = relaciones[x][0]
newRelation['idItem2'] = int(itemnuevo.id)
self.provider.create(RelacionItem, params=newRelation)
raise redirect('./?iid=' + str(kw['idItem1']))
def delete(self, fileid):
#log.debug("Soy Archivo Borrado")
"""Se extrae el ID del Item que supuestamente se borrará, para crear un nuevo Item """
iid=DBSession.query(Adjuntos.idItem).filter_by(id=fileid).first()
"""Se crea un nuevo item"""
itemeditado=DBSession.query(Item).filter_by(id=iid).first()
itemnuevo=Item()
itemnuevo.version=itemeditado.version + 1
itemnuevo.idTipoDeItem=itemeditado.idTipoDeItem
itemnuevo.idFase=itemeditado.idFase
itemnuevo.idLineaBase=itemeditado.idLineaBase
itemnuevo.fechaCreacion=itemeditado.fechaCreacion
itemnuevo.nrohistorial=itemeditado.nrohistorial
itemnuevo.ultimaversion=1
itemeditado.ultimaversion=0
itemnuevo.estado='modificado'
itemnuevo.complejidad=itemeditado.complejidad
itemnuevo.nombre=itemeditado.nombre
DBSession.add(itemnuevo)
"""Realiza copia de los valores de los atributos especificos"""
atributoeditado=DBSession.query(DetalleItem).filter_by(iditem=itemeditado.id).all()
for objeto in atributoeditado:
nuevoDetalle=DetalleItem()
nuevoDetalle.tipo=objeto.tipo
nuevoDetalle.nombrecampo=objeto.nombrecampo
nuevoDetalle.valor=objeto.valor
nuevoDetalle.iditem=itemnuevo.id
DBSession.add(nuevoDetalle)
"""Realiza copia de los adjuntos"""
adjuntositemeditado=DBSession.query(Adjuntos).filter_by(idItem=itemeditado.id).all()
for adj in adjuntositemeditado:
log.debug("adjuntoBorraado: %s" %adj.id)
log.debug("fileid: %s" %fileid)
if str(adj.id) != str(fileid): #No se copiará el archivo "supuestamente" borrado
log.debug("fileid2: %s" %fileid)
itemnuevoadjunto=Adjuntos()
itemnuevoadjunto.idItem=itemnuevo.id
itemnuevoadjunto.filename=adj.filename
itemnuevoadjunto.filecontent=adj.filecontent
DBSession.add(itemnuevoadjunto)
"""Copia las relaciones """
relaciones = DBSession.query(RelacionItem.idItem1,RelacionItem.idItem2).filter((RelacionItem.idItem2==itemeditado.id) | (RelacionItem.idItem1==itemeditado.id)).all()
longitud = len(relaciones)
for x in range(longitud):
newRelation=RelacionItem()
log.debug('Creando relaciones')
if int(itemeditado.id) == int(relaciones[x][0]):
newRelation.idItem1=int(itemnuevo.id)
newRelation.idItem2=relaciones[x][1]
DBSession.add(newRelation)
#self.provider.create(RelacionItem, params=newRelation)
elif int(itemeditado.id) == int(relaciones[x][1]):
newRelation.idItem1=relaciones[x][0]
newRelation.idItem2=int(itemnuevo.id)
DBSession.add(newRelation)
return redirect("../../adjuntos/new/?iid="+str(itemnuevo.id))