def save(self, userfile):
forbidden_files = [".js", ".htm", ".html", ".mp3"]
for forbidden_file in forbidden_files:
if not hasattr(userfile,'filename'):
redirect('file_upload?validate=error')
elif userfile.filename.find(forbidden_file) != -1:
return redirect("/")
versionItem = DBSession.query(VersionItem).\
filter(VersionItem.id_version_item == Globals.\
current_item.id_version_item).one()
filecontent = userfile.file.read()
new_file = AtributoArchivo(filename=userfile.filename, filecontent=filecontent)
DBSession.add(new_file)
atributo = DBSession.query(AtributoItem).\
filter(AtributoItem.id_version_item==versionItem.id_version_item).\
filter(AtributoItem.id_atributo == Globals.current_atributo.id_atributo).one()
atributo.atributoArchivo = new_file
redirect("/item/atributosItem?id_version="+\
str(versionItem.id_version_item) + ";frompage=item")
def aprobar(self, **kw):
print '***************************************************************************************************************'
print 'entro aca'
lineaBase_id = kw['idlineaBase']
nroLineaBaseAprobar = DBSession.query(NroLineaBase).\
filter(NroLineaBase.id_nro_lb == lineaBase_id).one()
items = nroLineaBaseAprobar.item
band = 1
if (items == []):
band = 0
flash(_("ERROR!! NO SE PUEDE APROBAR UNA LINEA BASE SIN ITEMS"))
redirect("/lineaBase/index?id_fase="+str(Globals.current_phase.id_fase))
else:
estadoA = DBSession.query(Estado).filter(Estado.nom_estado == 'Aprobado').one()
for itemEstado in nroLineaBaseAprobar.item:
itemEstado.estado = estadoA
Globals.current_phase.id_estado = estadoA.id_estado
nroLineaBaseAprobar.id_estado = estadoA.id_estado
DBSession.add(nroLineaBaseAprobar)
DBSession.flush()
flash(_("LA LINEA BASE HA SIDO APROBADA"))
redirect("/lineaBase/index?id_fase="+str(Globals.current_phase.id_fase))
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 savePhase(self, **kw):
Phase = Fase()
project = DBSession.query(Proyecto).\
filter(Proyecto.id_proyecto == Globals.current_project.id_proyecto).one()
estado =DBSession.query(Estado).\
filter(Estado.nom_estado == 'Inicial').one()
Phase.proyectoFase = project
Phase.estadoFase = estado
Phase.nro_fase = kw['nroPhase']
Phase.nom_fase = kw['phaseName']
Phase.des_fase = kw['descripcion']
DBSession.add(Phase)
flash(_("Se ha creado una nueva Fase: %s") %kw['phaseName'],'info')
redirect("index?id_proyecto="+str(Globals.current_project.id_proyecto))
def saveProject(self, **kw):
"""
Funcion que se encarga de guardar los datos introducidos en el formulario
para el nuevo proyecto.
Al crear un nuevo proyecto se establece el estado de este
en 'No Iniciado'
"""
aProject = Proyecto()
estado =DBSession.query(Estado).filter(Estado.nom_estado == 'No Iniciado').one()
aProject.estadoProyecto = estado
aProject.nom_proyecto = kw['projectName']
aProject.des_proyecto = kw['descripcion']
DBSession.add(aProject)
flash(_("Se ha creado un nuevo Proyecto: %s") %kw['projectName'],'info')
redirect("adminProject")
def abrirLineaBase(self, **kw):
print 'abrir linea base'
lineaBase = kw['idlineaBase']
estadoD = DBSession.query(Estado).filter(Estado.nom_estado == 'En Desarrollo').one()
Globals.current_phase.id_estado = estadoD.id_estado
estadoA = DBSession.query(Estado).filter(Estado.nom_estado == 'Abierta').one()
usuario = DBSession.query(Usuario).filter(Usuario.login_name == request.identity['repoze.who.userid']).one()
nroLineaBase = DBSession.query(NroLineaBase).filter(NroLineaBase.id_nro_lb == lineaBase).one()
aNroLineaBase = NroLineaBase()
aNroLineaBase.id_linea_base = nroLineaBase.id_linea_base
aNroLineaBase.nro_linea_base = nroLineaBase.nro_linea_base + 1
aNroLineaBase.id_estado = estadoA.id_estado
aNroLineaBase.id_usuario_aprobo = usuario.id_usuario
items = nroLineaBase.item
estadoC = DBSession.query(Estado).filter(Estado.nom_estado == 'Confirmado').one()
for itemGuardar in items:
itemGuardar.estado = estadoC
aNroLineaBase.item.append(itemGuardar)
print 'ABRIR/NUEVA VERSION ID '
print aNroLineaBase.id_linea_base
print 'ABRIR/NUEVA nro_linea_base '
print aNroLineaBase.nro_linea_base
print 'ABRIR/NUEVA id_estado '
print aNroLineaBase.id_estado
DBSession.add(aNroLineaBase)
DBSession.flush()
flash(_("LA LINEA BASE HA SIDO ABIERTA"))
redirect("/lineaBase/index?id_fase="+str(Globals.current_phase.id_fase))
def saveImport(self,**kw):
fase = DBSession.query(Fase).\
filter(Fase.id_fase==Globals.current_phase.id_fase).one()
tipo=DBSession.query(TipoItem).filter(TipoItem.id_tipo_item==int(kw['id_tipo'])).one()
tipoNew = TipoItem()
tipoNew.nom_tipo_item = tipo.nom_tipo_item
tipoNew.fase = fase
tipoNew.prefijo = tipo.prefijo
tipoNew.cont_prefijo = 0
list_atributos = []
for atributo in tipo.Atributo:
list_atributos.append(Atributo(atributo.nom_atributo,
atributo.tipoDatoAtributo,
tipoNew))
DBSession.add(tipoNew)
DBSession.add_all(list_atributos)
redirect('/fase/importTipoItem')
def saveUser(self, **kw):
"""Create a movie object and save it to the database."""
user = Usuario()
user.nom_usuario = kw['userName']
user.login_name = kw['loginName']
user._set_password(kw['password'])
type = int(kw['userType'])
DBSession.add(user)
if type == 1:
grupo = DBSession.query(Group).filter(Group.group_name=='admin').one()
grupo.users.append(user)
else:
grupo = DBSession.query(Group).filter(Group.group_name=='user').one()
grupo.users.append(user)
DBSession.flush()
#flash("El Usuario ha sido registrado satisfactoriamente.")
redirect("adminUsers")
def saveItem(self, **kw):
unItem = Item()
unItem.nom_item = kw["nomItem"]
# aProject.des_proyecto = kw['descripcion']
DBSession.add(unItem)
unaVersionItem = VersionItem()
unaVersionItem.item = unItem
unEstado = DBSession.query(Estado).filter_by(id_estado=1).one()
unTipoItem = DBSession.query(TipoItem).filter_by(id_tipo_item=1).one()
unUsuario = DBSession.query(Usuario).filter_by(id_usuario=1).one()
unaVersionItem.estado = unEstado
unaVersionItem.tipoItem = unTipoItem
unaVersionItem.usuarioModifico = unUsuario
unaVersionItem.fecha = "10/06/2011"
unaVersionItem.observaciones = kw["observaciones"]
# unaVersionItem.peso = kw['peso']
DBSession.add(unaVersionItem)
for atributo in DBSession.query(Atributo).filter_by(tipoItem=unTipoItem):
nuevoAtributoItem = AtributoItem()
nuevoAtributoItem.atributo = atributo
nuevoAtributoItem.versionItem = unaVersionItem
nuevoAtributoItem.val_atributo = atributo.val_default
DBSession.add(nuevoAtributoItem)
flash(_("Se ha creado un nuevo Item: %s") % kw["itemName"], "info")
redirect("adminItem")
def guardarLineaBase(self, **kw):
"""
Funcion que se encarga de guardar los datos introducidos en el formulario
para la nueva linea base.
"""
aLineaBase = LineaBase()
fase = DBSession.query(Fase).filter(Fase.id_fase == self.fase_id).one()
usuario = DBSession.query(Usuario).filter(Usuario.login_name == request.identity['repoze.who.userid']).one()
estado =DBSession.query(Estado).filter(Estado.nom_estado == 'Aprobado').one()
aLineaBase.id_fase = fase.id_fase
aLineaBase.nom_linea_base = kw['nombreLineaBase']
aLineaBase.descripcion = kw['descripcionLineaBase']
aItemsSelecionados = kw['listaItem']
DBSession.add(aLineaBase)
DBSession.flush()
print aLineaBase.id_linea_base
aNroLineaBase = NroLineaBase()
aNroLineaBase.id_linea_base = aLineaBase.id_linea_base
aNroLineaBase.nro_linea_base = 1
aNroLineaBase.id_estado = estado.id_estado
aNroLineaBase.id_usuario_aprobo = usuario.id_usuario
for items1 in aItemsSelecionados:
itemSelect = DBSession.query(VersionItem).filter(VersionItem.id_version_item ==items1).one()
print itemSelect.observaciones
itemSelect.id_estado = estado.id_estado
aNroLineaBase.item.append(itemSelect)
DBSession.add(aNroLineaBase)
DBSession.flush()
flash(_("Se ha creado una nueva Linea Base: %s") %kw['nombreLineaBase'],'info')
redirect("index?id_fase="+str(self.fase_id))
def saveAtributo(self, **kw):
tipoItem = DBSession.query(TipoItem).\
filter(TipoItem.id_tipo_item==(kw['id_tipo'])).one()
tipoDato = DBSession.query(TipoDatoAtributo).\
filter(TipoDatoAtributo.id_tipo_dato==int(kw['tipo_dato'])).one()
if int(kw['save_as']) == 0:
'''Opcion para Nuevos Items'''
newAtri = Atributo(kw['nom_atributo'], tipoDato, tipoItem)
if tipoDato.nom_tipo_dato == 'numerico':
newAtri.val_default = kw['def_numerico']
elif tipoDato.nom_tipo_dato == 'texto':
newAtri.val_default = kw['def_texto']
elif tipoDato.nom_tipo_dato == 'fecha':
if not kw['def_fecha'] == None:
newAtri.val_default = kw['def_fecha'].strftime('%d/%m/%y')
else:
newAtri.val_default = kw['def_fecha']
else:
'''Opcion para Nuevos y Actuales Items'''
newAtri = Atributo(kw['nom_atributo'], tipoDato, tipoItem)
if tipoDato.nom_tipo_dato == 'numerico':
newAtri.val_default = kw['def_numerico']
elif tipoDato.nom_tipo_dato == 'texto':
newAtri.val_default = kw['def_texto']
elif tipoDato.nom_tipo_dato == 'fecha':
if not kw['def_fecha'] == None:
newAtri.val_default = kw['def_fecha'].strftime('%d/%m/%y')
else:
newAtri.val_default = kw['def_fecha']
item_list = DBSession.query(VersionItem).\
filter(VersionItem.ultima_version == 'S').\
filter(VersionItem.tipoItem==tipoItem).all()
for item in item_list:
item.ultima_version = 'N'
lg_name=request.identity['repoze.who.userid']
usuario = DBSession.query(Usuario).\
filter(Usuario.login_name==lg_name).one()
nuevaVersionItem = VersionItem()
nuevaVersionItem.item = item.item
nuevaVersionItem.nro_version_item = item.nro_version_item+1
nuevaVersionItem.estado = item.estado
nuevaVersionItem.tipoItem = item.tipoItem
nuevaVersionItem.usuarioModifico = usuario
nuevaVersionItem.fecha = str(datetime.now())
nuevaVersionItem.observaciones = item.observaciones
nuevaVersionItem.ultima_version = 'S'
nuevaVersionItem.peso = item.peso
nuevaVersionItem.id_fase = item.id_fase
# Agregar los antecesores del item viejo
for antecesor in item.Antecesores:
nuevaVersionItem.Antecesores.append(antecesor)
# Agregar los sucesores del item viejo
try:
antecesor = DBSession.query(Antecesor).\
filter(Antecesor.id_version_item == item.id_version_item).\
one()
nuevoAntecesor = Antecesor(nuevaVersionItem.id_version_item)
sucesores = antecesor.sucesores
for sucesor in sucesores:
sucesor.Antecesores.append(nuevoAntecesor)
except NoResultFound,e:
existe=False
# Agregar los padres del item viejo
for padre in item.Padres:
nuevaVersionItem.Padres.append(padre)
# Agregar los hijos del item viejo
try:
padre = DBSession.query(Padre).\
filter(Padre.id_version_item == item.id_version_item).\
one()
nuevoPadre = Padre(nuevaVersionItem.id_version_item)
hijos = padre.hijos
for hijo in hijos:
hijo.Padres.append(nuevoPadre)
except NoResultFound,e:
existe=False
# Copiamos los atributos del item viejo
for atributo in DBSession.query(AtributoItem).\
filter(AtributoItem.id_version_item == item.id_version_item).all():
nuevoAtributoItem = AtributoItem()
nuevoAtributoItem.id_atributo = atributo.id_atributo
nuevoAtributoItem.id_version_item = nuevaVersionItem.id_version_item
nuevoAtributoItem.val_atributo = atributo.val_atributo
DBSession.add(nuevoAtributoItem)
atriItem = AtributoItem()
atriItem.atributo = newAtri
atriItem.id_version_item = nuevaVersionItem.id_version_item
atriItem.val_atributo = newAtri.val_default
DBSession.add(atriItem)
def pendiente(self, **kw):
self.nro_lb_id = kw['idlineaBase']
'''traer todas las versiones de items que pertenecen a la linea base abierta'''
lineaBase = DBSession.query(NroLineaBase).filter(NroLineaBase.id_nro_lb == self.nro_lb_id).one()
itemlineabase = lineaBase.item
estadoItem = DBSession.query(Estado).filter(Estado.nom_estado == 'Confirmado').one()
estadoR = DBSession.query(Estado).filter(Estado.nom_estado == 'En Revision').one()
estadoA = DBSession.query(Estado).filter(Estado.nom_estado == 'Aprobado').one()
itemsAnteriores = []
items=[]
for item in itemlineabase:
queryItem = DBSession.query(Item).filter(Item.id_item == item.id_item).one()
items.append(queryItem)
print 'pasa esto 1'
versionItem=[]
for item in items:
max=-1
for item2 in item.VersionItem:
if (item2.nro_version_item > max):
max = item2.nro_version_item
last_version = item2
versionItem.append(last_version)
print 'pasa esto 2'
cambios=[]
sinCambios=[]
for item in itemlineabase:
for item3 in versionItem:
if((item.id_item == item3.id_item) and (item3.nro_version_item > item.nro_version_item)):
cambios.append(item3)
break
if((item.id_item == item3.id_item) and(item3.nro_version_item == item.nro_version_item)):
sinCambios.append(item3)
break
listaGuardar = []
for itemActualizado in cambios:
itemSelect = DBSession.query(VersionItem).\
filter(VersionItem.id_version_item == itemActualizado.id_version_item).one()
#itemSelect.estado = estadoA
listaGuardar.append(itemSelect)
for itemNoActualizado in sinCambios:
itemSelect1 = DBSession.query(VersionItem).\
filter(VersionItem.id_version_item == itemNoActualizado.id_version_item).one()
#itemSelect1.estado = estadoA
listaGuardar.append(itemSelect1)
#Esta variable del tipo lista tendra todos los items relacionados a 'item'
ListaItems = []
ListaIzq = []
for itemP in listaGuardar:
if (itemP.estado != estadoItem):
flash(_("ATENCION!! EXISTEN ITEMS DE LA FASE QUE AUN NO HAN SIDO CONFIRMADOS"),"warning")
redirect("/lineaBase/index?id_fase="+str(Globals.current_phase.id_fase))
#El item modificado que se quiere volver a la LB
item = DBSession.query(VersionItem).\
filter(VersionItem.id_version_item==itemP.id_version_item).one()
#Obtener la red de relaciones desde este item
item.initGraph(item)
#Obtenemos relaciones de la Izquierda
ListaItems.extend(item.getRelacionesIzq(item.id_version_item))
ListaIzq.extend(item.getRelacionesIzq(item.id_version_item))
#Obtenemos relaciones de Abajo
hijos=item.getHijos(item.id_version_item)
ListaItems.extend(item.getHijosNietos(hijos))
#Obtenemos relaciones de la Derecha
ListaItems.extend(item.getRelacionesDer(item.id_version_item))
bandR = 0
for test in ListaItems:
itemRelacion = DBSession.query(VersionItem).\
filter(VersionItem.id_version_item == test.id_version_item).one()
if (itemRelacion.estado == estadoR):
bandR = 1
if (bandR == 1):
break
if (bandR == 1):
break
band = 1
if (ListaItems == []):
band = 0
flash(_("ATENCION!! NO EXISTEN ITEMS"),"warning")
redirect("/lineaBase/index?id_fase="+str(Globals.current_phase.id_fase))
elif(bandR == 1):
flash(_("ATENCION!! EXISTEN ITEMS DE OTRAS FASES EN REVISION"),"warning")
redirect("/lineaBase/index?id_fase="+str(Globals.current_phase.id_fase))
else:
estadoP = DBSession.query(Estado).filter(Estado.nom_estado == 'Pendiente').one()
lineaBase = DBSession.query(NroLineaBase).filter(NroLineaBase.id_nro_lb == self.nro_lb_id).one()
estadoE = DBSession.query(Estado).filter(Estado.nom_estado == 'Eliminado').one()
faseList = DBSession.query(Fase).\
filter(Fase.id_proyecto==Globals.current_project.id_proyecto).\
order_by(Fase.nro_fase).all()
print '**************************************************hola************************************************************'
print faseList[0].nro_fase
print ListaIzq
if(Globals.current_phase.nro_fase != faseList[0].nro_fase):
bandA = 0
for itemP in listaGuardar:
antecesores = itemP.Antecesores
for antecesor in antecesores:
itemAntecesor = DBSession.query(VersionItem).\
filter(VersionItem.id_version_item==antecesor.id_version_item).one()
if(itemAntecesor.estado != estadoA and itemAntecesor.ultima_version == 'S' and itemAntecesor.estado.nom_estado != "Eliminado"):
flash(_("ATENCION!! DEBE APROBAR PRIMERO LA LINEA BASE DE LA FASE ANTERIOR"),'warning')
redirect("/lineaBase/index?id_fase="+str(Globals.current_phase.id_fase))
lista=[]
Globals.current_phase.id_estado = estadoP.id_estado
lineaBase.id_estado = estadoP.id_estado
for i in lineaBase.item:
lista.append(i)
for element in lista:
lineaBase.item.remove(element)
DBSession.flush()
for item in listaGuardar:
itemSelect3 = DBSession.query(VersionItem).\
filter(VersionItem.id_version_item == item.id_version_item).one()
if(itemSelect3.estado == estadoItem):
itemSelect3.estado = estadoA
lineaBase.item.append(itemSelect3)
DBSession.add(lineaBase)
DBSession.flush()
flash(_("LA LINEA BASE HA PASADO A UN ESTADO PENDIENTE DE APROBACION"))
redirect("/lineaBase/index?id_fase="+str(Globals.current_phase.id_fase))
