def view_gantt(request):
doc = Document()
wml = doc.createElement("project")
doc.appendChild(wml)
id_proyecto = request.GET.get('id_proyecto')
fase_dao = FaseDAO(request)
fases = fase_dao.get_query().filter(
Fase._proyecto_id == id_proyecto).order_by(Fase._orden.asc()).all()
item_dao = ItemDAO(request)
xml = "<project>"
for fase in fases:
task = Task()
task.set_fase(fase)
wml.appendChild(task.get_xml(doc))
xml += task.to_xml()
entidades = item_dao.get_items_fase(fase._id)
for item in entidades:
task = Task()
task.set_item(item)
wml.appendChild(task.get_xml(doc))
xml += task.to_xml()
xml += "</project>"
# print xml
# Print our newly created XML
# print doc.toprettyxml(indent=" ")
return Response(xml)
def get_fase_antecesora(request, fase):
fase_id = fase._id
proyecto_id = fase._proyecto_id
rd = FaseDAO(request)
lista = [];
#Codigo de fede
fase_actual = rd.get_by_id(fase_id)
entidad = rd.get_query().filter(Fase._proyecto_id == proyecto_id, Fase._orden < fase_actual._orden).order_by(Fase._orden.desc()).first()
return entidad;
def get_fases(request):
dao = FaseDAO(request);
entidades = dao.get_all();
p = Pickler();
lista = [];
for entidad in entidades:
lista.append(p.flatten(EntidadPadreDTO(entidad)));
j_string = p.flatten(lista)
a_ret = json.dumps({'sucess': 'true', 'entidades':j_string})
return Response(a_ret)
def create_proyectos(request):
"""
@summary: Maneja las solicitudes para crear los proyectos. El proyecto nuevo se crea
con una fase por defecto, a la cual se le asocia un tipo de item por defecto
@param request: Solicitud de creacion.
@return: Retorna el proyecto creado.
"""
u = Unpickler()
entidad = u.restore(request.json_body)
dao = ProyectoDAO(request)
rol_dao = RolFinalDAO(request)
rol = rol_dao.get_query().filter(
RolFinal._id == entidad["_autor_id"]).first()
lider = rol_dao.get_query().filter(
RolFinal._id == entidad["_lider_id"]).first()
nuevo_proyecto = Proyecto(entidad["_nombre"], rol, entidad["_prioridad"],
entidad["_estado"], lider, entidad["_nota"],
entidad["_fecha_creacion"],
entidad["_fecha_modificacion"])
dao.crear(nuevo_proyecto)
#le creamos una fase por defecto
nombre_fase = "Fase por defecto de " + entidad["_nombre"]
orden = 1
comentario = "Fase creada por defecto"
estado = "PENDIENTE"
color = "0"
nueva_fase = Fase(nombre_fase, nuevo_proyecto, orden, comentario, estado,
color)
dao_fase = FaseDAO(request)
dao_fase.crear(nueva_fase)
asignar_permiso_rol_proyecto(request, nuevo_proyecto._autor,
nuevo_proyecto)
asignar_permiso_rol_proyecto(request, nuevo_proyecto._lider,
nuevo_proyecto)
#Le asociamos un tipo de item por defecto a esa fase por defecto
# dao_tipo_item = TipoItemDAO(request)
# tipo_item = dao_tipo_item.get_by_id(1)
# nuevo_tipo_fase = TipoFase(nueva_fase,tipo_item)
# dao_tipo_fase = TipoFaseDAO(request)
# dao_tipo_fase.crear(nuevo_tipo_fase)
lista = []
p = Pickler()
a = ProyectoDTO(nuevo_proyecto)
lista.append(p.flatten(a))
j_string = p.flatten(lista)
a_ret = json.dumps({'sucess': 'true', 'proyectos': j_string})
return Response(a_ret)
def test_it(self):
dao = ProyectoDAO(None)
rol_dao = RolFinalDAO(None)
autor = rol_dao.get_by_id(1)
lider = rol_dao.get_by_id(1)
nuevo_proyecto = Proyecto("Test", autor, 1, "Prueba", lider, "Prueba",
"hoy", "hoy")
dao.crear(nuevo_proyecto)
dao = FaseDAO(None)
nueva_fase = Fase("Testeando", nuevo_proyecto, 2, "Prueba", "Prueba",
"0")
dao.crear(nueva_fase)
dao = AtributoFaseDAO(None)
nuevo_atributo = AtributoFase("Atributo de prueba", nueva_fase,
"Prueba", "100")
dao.crear(nuevo_atributo)
direccion = '/atributofase/' + str(nuevo_atributo.id)
atributo = {
"_nombre": "Atributo 1",
"id": nuevo_atributo.id,
"_fase_id": nueva_fase.id,
"_descripcion": "Prueba",
"_valor": "100"
}
res = self.testapp.delete(direccion, params=json.dumps(atributo))
print "Testeando eliminar atributo de fase"
self.failUnless('sucess' in res.body)
def test_it(self):
dao = ProyectoDAO(None)
rol_dao = RolFinalDAO(None)
autor = rol_dao.get_by_id(1)
lider = rol_dao.get_by_id(1)
nuevo_proyecto = Proyecto("Test", autor, 1, "Prueba", lider, "Prueba",
"hoy", "hoy")
dao.crear(nuevo_proyecto)
dao = FaseDAO(None)
nueva_fase = Fase("Testeando", nuevo_proyecto, 2, "Prueba", "Prueba",
"0")
dao.crear(nueva_fase)
esquema = {
"_nombre": "Esquema Prueba",
"_descripcion": "Prueba",
"_etiqueta": "Esquema",
"_color": "0",
"_fase_id": nueva_fase.id
}
res = self.testapp.post('/esquemas', params=json.dumps(esquema))
print "Testeando crear esquema"
self.failUnless('sucess' in res.body)
def test_it(self):
dao = ProyectoDAO(None)
rol_dao = RolFinalDAO(None)
autor = rol_dao.get_by_id(1)
lider = rol_dao.get_by_id(1)
nuevo_proyecto = Proyecto("Test", autor, 1, "Prueba", lider, "Prueba",
"hoy", "hoy")
dao.crear(nuevo_proyecto)
dao = FaseDAO(None)
nueva_fase = Fase("Testeando", nuevo_proyecto, 2, "Prueba", "Prueba",
"0")
dao.crear(nueva_fase)
esquemaDao = EsquemaDAO(None)
nuevo_esquema = Esquema("Esquema", "_descripcion", "_etiqueta",
"_color", nueva_fase.id)
esquemaDao.crear(nuevo_esquema)
nueva_entidad = {
"_nombre": "Prueba",
"_descripcion": "prueba",
"_tipo": "numerico",
"_valor": "100",
"_esquema_id": nuevo_esquema.id
}
res = self.testapp.post('/atributosEsquemas',
params=json.dumps(nueva_entidad))
print "Testeando crear atributos de esquema"
self.failUnless('sucess' in res.body)
def test_it(self):
dao = ProyectoDAO(None)
rol_dao = RolFinalDAO(None)
autor = rol_dao.get_by_id(1)
lider = rol_dao.get_by_id(1)
nuevo_proyecto = Proyecto("Test", autor, 1, "Prueba", lider, "Prueba",
"hoy", "hoy")
dao.crear(nuevo_proyecto)
dao = FaseDAO(None)
nueva_fase = Fase("Testeando", nuevo_proyecto, 2, "Prueba", "Prueba",
"0")
dao.crear(nueva_fase)
dao = TipoItemDAO(None)
tipo = dao.get_by_id(1)
dao = TipoFaseDAO(None)
nuevo_tipo_fase = TipoFase(nueva_fase, tipo)
dao.crear(nuevo_tipo_fase)
direccion = '/tipofase/' + str(nuevo_tipo_fase.id)
tipo_fase = {
"id": nuevo_tipo_fase.id,
"_tipo": 2,
"tipo_nombre": "Tipo 1",
"_fase": 70
}
res = self.testapp.delete(direccion, params=json.dumps(tipo_fase))
print "Testeando eliminar asociacion entre tipo de item y fase"
self.failUnless('sucess' in res.body)
def test_it(self):
dao = ProyectoDAO(None)
rol_dao = RolFinalDAO(None)
autor = rol_dao.get_by_id(1)
lider = rol_dao.get_by_id(1)
nuevo_proyecto = Proyecto("Test", autor, 1, "Prueba", lider, "Prueba",
"hoy", "hoy")
dao.crear(nuevo_proyecto)
dao = FaseDAO(None)
nueva_fase = Fase("Testeando", nuevo_proyecto, 2, "Prueba", "Prueba",
"0")
dao.crear(nueva_fase)
direccion = '/fases/' + str(nueva_fase.id)
fase = {
"_nombre": "Fase 3",
"id": nueva_fase.id,
"_proyecto_id": 69,
"_orden": 3,
"_comentario": "Prueba",
"_estado": "Pendiente",
"_color": "008080"
}
res = self.testapp.delete(direccion, params=json.dumps(fase))
print "Testeando eliminar fases"
self.failUnless('sucess' in res.body)
def test_it(self):
dao = ProyectoDAO(None)
rol_dao = RolFinalDAO(None)
autor = rol_dao.get_by_id(1)
lider = rol_dao.get_by_id(1)
nuevo_proyecto = Proyecto("Test", autor, 1, "Prueba", lider, "Prueba",
"hoy", "hoy")
dao.crear(nuevo_proyecto)
dao = FaseDAO(None)
nueva_fase = Fase("Testeando", nuevo_proyecto, 2, "Prueba", "Prueba",
"0")
dao.crear(nueva_fase)
esquemaDao = EsquemaDAO(None)
nueva_entidad = Esquema("Esquema", "_descripcion", "_etiqueta",
"_color", nueva_fase.id)
esquemaDao.crear(nueva_entidad)
direccion = '/esquemas/' + str(nueva_entidad.id)
esquema = {
"id": nueva_entidad.id,
"_nombre": "Esquema Prueba",
"_descripcion": "Prueba",
"_etiqueta": "Esquema",
"_color": "0",
"_fase_id": nueva_fase.id
}
res = self.testapp.delete(direccion, params=json.dumps(esquema))
print "Testeando eliminar esquemas"
self.failUnless('sucess' in res.body)
def actualizar_eliminar_fase(request):
"""
@summary: Maneja las solicitudes para actualizar y elimninar fases.
Al eliminar la fase se eliminan sus atributos particulares y los tipos de items que soporta.
@param request: Delete para eliminar y Put para modificar.
@return: En caso de recibir un Put retorna la fase creada.
En caso de recibir un Delete retorna true en caso de exito .
"""
if (request.method == 'DELETE'):
u = Unpickler()
entidad = u.restore(request.json_body);
dao = FaseDAO(request)
fase = dao.get_by_id(entidad["id"])
#eliminamos los atributos particulares de la fase
atributo_fase_dao = AtributoFaseDAO(request)
atributos = atributo_fase_dao.get_query().filter(AtributoFase._fase_id == fase._id).all();
for atributo in atributos:
atributo_fase_dao.borrar(atributo);
#eliminamos las asociaciones que puede tener con los tipos de items
tipo_fase_dao = TipoFaseDAO(request)
tipos = tipo_fase_dao.get_query().filter(TipoFase._fase_id == fase._id).all();
for tipo in tipos:
tipo_fase_dao.borrar(tipo);
dao.borrar(fase)
return Response(json.dumps({'sucess': 'true'}))
else:
#Recibimos un PUT
u = Unpickler()
dao = FaseDAO(request)
entidad = u.restore(request.json_body);
vieja = dao.get_by_id(entidad["id"])
vieja._nombre = entidad["_nombre"]
vieja._orden = entidad["_orden"]
vieja._comentario = entidad["_comentario"]
vieja._color = entidad["_color"]
dao.update(vieja)
lista = []
p = Pickler()
lista.append(p.flatten(vieja))
j_string = p.flatten(lista)
return Response(json.dumps({'sucess': 'true', 'fases':j_string}))
def delete_proyectos(request):
"""
@summary: Maneja las solicitudes para eliminar proyectos.
@param request: Solicitud de eliminacion.
@return: Retorna true en caso de exito.
"""
u = Unpickler()
entidad = u.restore(request.json_body)
dao = ProyectoDAO(request)
proyecto = dao.get_by_id(entidad["id"])
fase_dao = FaseDAO(request)
fases = fase_dao.get_query().filter(
Fase._proyecto_id == proyecto._id).all()
for fase in fases:
fase_dao.borrar(fase)
dao.borrar(proyecto)
return Response(json.dumps({'sucess': 'true'}))
def rest(request):
if (request.method == 'POST'):
try:
u = Unpickler()
objeto = u.restore(request.json_body)
if (objeto['_fase'] == ''):
raise FaseNoEncontradaException()
fase_dao = FaseDAO(request)
fase = fase_dao.get_by_id(objeto['_fase'])
if (objeto['_items'] == None or objeto['_items'] == ''):
raise NoItemLineaBaseException()
item_dao = ItemDAO(request)
items = []
for item_id in objeto['_items']:
items.append(item_dao.get_by_id(item_id))
dao_item = ItemDAO(request)
nItems = []
for item in items:
n_item = Item(item._item_id, item._nombre, item._tipo_item,
item._fase, item._duracion, item._descripcion,
item._condicionado, item._version + 1,
"BLOQUEADO", item._fecha_inicio,
item._completado, item._padre_item_id,
item._antecesor_item_id, item._color)
dao_item.crear(n_item)
nItems.append(n_item)
actualizar_referencias_item(n_item, item_dao, item._id, False)
item_dao.actualizarEstadosFaseyProyecto(n_item)
item_dao.actualizarReferenciasItemNuevaVersion(n_item._id)
linea_base = LineaBase(objeto['_nombre'], objeto['_descripcion'],
fase, nItems)
dao = LineaBaseDAO(request)
dao.crear(linea_base)
p = Pickler()
aRet = p.flatten(linea_base)
return Response(json.dumps({'sucess': 'true', 'entidades': aRet}))
except FaseNoEncontradaException, e:
print e
return Response(json.dumps({'sucess': 'false'}))
return Response(json.dumps({'sucess': 'false'}))
def get_dao(self, clase, request):
if clase not in self.daos:
if clase == Item:
self.daos[Item] = ItemDAO(request)
if clase == Fase :
self.daos[Fase] = FaseDAO(request)
if clase == Proyecto :
self.daos[Proyecto] = ProyectoDAO(request)
if clase == LineaBase :
self.daos[LineaBase] = LineaBaseDAO(request)
if clase == Esquema :
self.daos[Esquema] = EsquemaDAO(request)
return self.daos[clase]
def obtener_crear_tipofase(request):
"""
@summary: Maneja las solicitudes para obtener y asociar tipos de items a una fase en particular.
@param request: Get para recuperar y Post para crear.
@return: En caso de recibir un Get retorna todos los tipos de items que soporta una fase en especifico.
En caso de recibir un Post asocia un tipo de item a una fase.
"""
if (request.method == 'GET'):
id = request.GET.get('id')
rd = TipoFaseDAO(request)
entidades = rd.get_query().filter(TipoFase._fase_id == id).all()
lista = [];
p = Pickler()
for entidad in entidades:
a = TipoFaseLindos(entidad._id, entidad._fase._id, entidad._tipo._id, entidad._tipo._nombre)
lista.append(p.flatten(a))
j_string = p.flatten(lista)
a_ret = json.dumps({'sucess': 'true', 'tipofase':j_string})
return Response(a_ret)
elif (request.method == 'POST'):
u = Unpickler()
entidad = u.restore(request.json_body);
dao = FaseDAO(request)
fase = dao.get_by_id(entidad["_fase"])
dao = TipoItemDAO(request)
tipo = dao.get_by_id(entidad["_tipo"])
dao = TipoFaseDAO(request)
nuevo_tipo_fase = TipoFase(fase, tipo)
dao.crear(nuevo_tipo_fase)
lista = []
p = Pickler()
a = TipoFaseLindos(nuevo_tipo_fase._id, nuevo_tipo_fase._fase._id, nuevo_tipo_fase._tipo._id, nuevo_tipo_fase._tipo._nombre)
lista.append(p.flatten(a))
j_string = p.flatten(lista)
a_ret = json.dumps({'sucess': 'true', 'tipofase' : j_string})
return Response(a_ret)
def test_it(self):
dao = ProyectoDAO(None)
rol_dao = RolFinalDAO(None)
autor = rol_dao.get_by_id(1)
lider = rol_dao.get_by_id(1)
nuevo_proyecto = Proyecto("Test", autor, 1, "Prueba", lider, "Prueba",
"hoy", "hoy")
dao.crear(nuevo_proyecto)
dao = FaseDAO(None)
nueva_fase = Fase("Testeando", nuevo_proyecto, 2, "Prueba", "Prueba",
"0")
dao.crear(nueva_fase)
esquemaDao = EsquemaDAO(None)
nuevo_esquema = Esquema("Esquema", "_descripcion", "_etiqueta",
"_color", nueva_fase.id)
esquemaDao.crear(nuevo_esquema)
atributoEsquemaDao = AtributoEsquemaDAO(None)
nuevo_atributo = AtributoEsquema("_nombre", "_descripcion", "_tipo",
"_valor", nuevo_esquema.id)
atributoEsquemaDao.crear(nuevo_atributo)
atributo = {
"id": nuevo_atributo.id,
"_nombre": "Prueba",
"_descripcion": "prueba",
"_tipo": "numerico",
"valor": 10,
"esquema_id": nuevo_esquema.id
}
direccion = '/atributosEsquemas/' + str(nuevo_atributo.id)
res = self.testapp.put(direccion, params=json.dumps(atributo))
print "Testeando modificar atributo de esquemas"
self.failUnless('sucess' in res.body)
def obtener_crear_atributofase(request):
"""
@summary: Maneja las solicitudes para obtener y crear atributos particulares de una fase.
@param request: Get para recuperar y Post para crear.
@return: En caso de recibir un Get retorna todos los atributos particulares de una fase en especifico.
En caso de recibir un Post retorna el atributo particular creado.
"""
if (request.method == 'GET'):
id = request.GET.get('id')
rd = AtributoFaseDAO(request)
entidades = rd.get_query().filter(AtributoFase._fase_id == id).all()
lista = [];
p = Pickler()
for entidad in entidades:
lista.append(p.flatten(entidad))
j_string = p.flatten(lista)
a_ret = json.dumps({'sucess': 'true', 'atributofase':j_string})
return Response(a_ret)
else:
#recibio un Post
u = Unpickler()
entidad = u.restore(request.json_body);
dao = FaseDAO(request)
fase = dao.get_by_id(entidad["_fase_id"])
dao = AtributoFaseDAO(request)
nuevo_atributo = AtributoFase(entidad["_nombre"], fase, entidad["_descripcion"], entidad["_valor"])
dao.crear(nuevo_atributo)
lista = []
p = Pickler()
lista.append(p.flatten(nuevo_atributo))
j_string = p.flatten(lista)
a_ret = json.dumps({'sucess': 'true', 'atributofase':j_string})
return Response(a_ret)
def obtener_crear_fases(request):
"""
@summary: Maneja las solicitudes para obtener y crear fases.
Las fases nuevas soportan por defecto un tipo de item.
@param request: Get para recuperar y Post para crear.
@return: En caso de recibir un Get retorna todas las fases de un proyecto en especifico.
En caso de recibir un Post retorna la fase creada.
"""
if (request.method == 'GET'):
proyecto_id = request.GET.get('id')
fase_id = request.GET.get('fase_id')
rd = FaseDAO(request)
lista = [];
p = Pickler(False, None)
#Codigo de fede
if (fase_id != None and fase_id != ""):
fase_actual = rd.get_by_id(fase_id)
entidad = rd.get_query().filter(Fase._proyecto_id == proyecto_id, Fase._orden < fase_actual._orden).order_by(Fase._orden.desc()).first()
if (entidad != None):
entidadLinda = FaseLinda(entidad._id, entidad._nombre, entidad._proyecto_id, entidad._orden, entidad._comentario, entidad._estado, entidad._color)
lista.append(p.flatten(entidadLinda))
elif (proyecto_id != None and proyecto_id != ""):
#Codigo de leo
#recuperamos todas las fases del proyecto
entidades = rd.get_query().filter(Fase._proyecto_id == proyecto_id).all()
for entidad in entidades:
entidadLinda = FaseLinda(entidad._id, entidad._nombre, entidad._proyecto_id, entidad._orden, entidad._comentario, entidad._estado, entidad._color)
lista.append(p.flatten(entidadLinda))
j_string = p.flatten(lista)
a_ret = json.dumps({'sucess': 'true', 'fases':j_string})
return Response(a_ret)
else:
#Recibimos un POST
u = Unpickler()
entidad = u.restore(request.json_body);
dao = ProyectoDAO(request)
proyecto = dao.get_by_id(entidad["_proyecto_id"])
dao = FaseDAO(request)
nueva_fase = Fase(entidad["_nombre"], proyecto, entidad["_orden"], entidad["_comentario"], entidad["_estado"], entidad["_color"])
dao.crear(nueva_fase)
#le asociamos el tipo de item
# dao_tipo_item = TipoItemDAO(request)
# tipo_item = dao_tipo_item.get_by_id(1)
# nuevo_tipo_fase = TipoFase(nueva_fase,tipo_item)
# dao_tipo_fase = TipoFaseDAO(request)
# dao_tipo_fase.crear(nuevo_tipo_fase)
lista = []
p = Pickler()
lista.append(p.flatten(nueva_fase))
j_string = p.flatten(lista)
a_ret = json.dumps({'sucess': 'true', 'fases':j_string})
return Response(a_ret)
def bm_atributo(request):
if (request.method == 'PUT' or request.method == 'DELETE'):
u = Unpickler()
entidad = u.restore(request.json_body);
item_dao = ItemDAO(request);
dao_fase = FaseDAO(request)
fase = dao_fase.get_by_id(entidad["_fase"]["_id"])
dao_tipo_item = TipoItemDAO(request)
tipo_item = dao_tipo_item.get_by_id((entidad["_tipo_item"]["_id"]))
dao_item_ante = ItemDAO(request)
if(entidad["_antecesor"] == "" or entidad["_antecesor"] == None):
antecesor = None
antecesor_id = None
else:
if isinstance(entidad["_antecesor"], int) != True:
antecesor_id = entidad["_antecesor"]["_id"]
antecesor = dao_item_ante.get_by_id(antecesor_id)
else:
antecesor = dao_item_ante.get_by_id(entidad["_antecesor"])
antecesor_id = antecesor._id
dao_item_padre = ItemDAO(request)
if(entidad["_padre"] == "" or entidad["_padre"] == None):
padre = None
padre_id = None
else:
if isinstance(entidad["_padre"], int) != True:
padre_id = entidad["_padre"]["_id"]
padre = dao_item_padre.get_by_id(padre_id)
else:
padre = dao_item_padre.get_by_id(entidad["_padre"])
padre_id = padre._id
item_viejo = item_dao.get_by_id(entidad["id"])
id_viejo = item_viejo._id;
formato_entrada = "%Y-%m-%dT%H:%M:%S"
if entidad["_fecha_inicio"]!= None and len(entidad["_fecha_inicio"])>1:
if entidad["_fecha_inicio"].find("T")>=0:
formato_entrada = "%Y-%m-%dT%H:%M:%S"
fecha_inicio = datetime.datetime.strptime(entidad["_fecha_inicio"],formato_entrada)
else:
formato_entrada = "%Y-%m-%d %H:%M:%S"
fecha_inicio = datetime.datetime.strptime(entidad["_fecha_inicio"],formato_entrada)
else:
fecha_inicio = ""
if padre != None and fecha_inicio != "":
if len(padre._fecha_inicio)>1:
if padre._fecha_inicio.find("T")>=0:
formato_entrada = "%Y-%m-%dT%H:%M:%S"
else:
formato_entrada = "%Y-%m-%d %H:%M:%S"
padre_inicio = datetime.datetime.strptime(padre._fecha_inicio, formato_entrada)
if fecha_inicio < padre_inicio:
return Response(json.dumps({'sucess': 'false', 'message':'La fecha de inicio asignada es menor a la fecha de inicio del padre'}))
if antecesor != None and fecha_inicio != "":
if len(antecesor._fecha_inicio)>1:
if antecesor._fecha_inicio.find("T")>=0:
formato_entrada = "%Y-%m-%dT%H:%M:%S"
else:
formato_entrada = "%Y-%m-%d %H:%M:%S"
if len(antecesor._fecha_inicio)>1:
antecesor_inicio = datetime.datetime.strptime(antecesor._fecha_inicio, formato_entrada)
if fecha_inicio < antecesor_inicio:
return Response(json.dumps({'sucess': 'false', 'message':'La fecha de inicio asignada es menor a la fecha de inicio del antecesor'}))
if entidad['_estado'] == "APROBADO":
print "HOLAAAAAAAAAAAAAAAAAAAAAA"
print entidad['_padre']
item_padre = get_entidad(entidad['_padre'], item_dao)
if (item_padre!= None):
if item_padre._estado == 'ELIMINADO' or item_padre._estado == 'REVISION':
return Response(json.dumps({'sucess': 'false', 'message':('No se puede Aprobar. El Padre del Item se encuentra en estado: ' + str(item_padre._estado))}))
else:
item_antecesor = get_entidad(entidad['_antecesor'], item_dao)
fase_antecesora = get_fase_antecesora(request, fase)
if fase_antecesora != None:
if item_antecesor == None:
return Response(json.dumps({'sucess': 'false', 'message':'No se puede Aprobar. El Item no tiene antecesor ni padre'}))
else :
if item_antecesor._estado == 'ELIMINADO' or item_antecesor._estado == 'REVISION':
return Response(json.dumps({'sucess': 'false', 'message':('No se puede Aprobar. El Antecesor del Item se encuentra en estado: ' + str(item_antecesor._estado))}))
if item_antecesor._linea_base_id == None :
return Response(json.dumps({'sucess': 'false', 'message':'No se puede Aprobar. Antecesor no tiene linea base'}))
nuevo_item = Item(item_viejo._item_id, entidad["_nombre"], tipo_item, fase, entidad["_duracion"], entidad["_descripcion"], entidad["_condicionado"], entidad["_version"], entidad["_estado"], fecha_inicio, entidad["_completado"], padre_id, antecesor_id, entidad["_color"])
if request.method == "DELETE":
nuevo_item._estado = "ELIMINADO"
nuevo_item._version += 1
item_dao.crear(nuevo_item);
padre = item_dao.get_by_id(nuevo_item._padre_item_id)
antecesor = item_dao.get_by_id(nuevo_item._antecesor_item_id)
if (nuevo_item._estado == "APROBADO" or nuevo_item._estado == "BLOQUEADO") == False:
actualizar_referencias_item(nuevo_item, item_dao, id_viejo)
else:
actualizar_referencias_item(nuevo_item, item_dao, id_viejo, False)
item_dao.actualizarEstadosFaseyProyecto(nuevo_item)
nuevo_item = ItemDTO(nuevo_item)
if padre != None:
nuevo_item._padre = ItemDTO(padre)
if antecesor != None:
nuevo_item._antecesor = ItemDTO(antecesor)
p = Pickler(False, None)
aRet = p.flatten(nuevo_item)
if (request.GET.get('actualizar') == "true"):
if (request.GET.get('rev') == "true"):
item_dao.actualizarReferenciasItemNuevaVersion(nuevo_item._id, entidad["id"])
else:
item_dao.actualizarReferenciasItemNuevaVersion(nuevo_item._id)
return Response(json.dumps({'sucess': 'true', 'lista':aRet}))
def ag_atributos_tipos_item(request):
if (request.method == 'GET'):
item_dao = ItemDAO(request)
fase_id = request.GET.get('id')
#Parte cocho
if request.GET.get('id_linea_base') != None:
return get_items_con_linea_base(request)
if request.GET.get('linea_base') == "false" and request.GET.get('id') != None:
return get_items_sin_linea_base_con_fase(request);
#END parte cocho
if request.GET.get('esquema') != None:
if request.GET.get('disponibles') == "true":
todas = item_dao.get_items_fase(fase_id)
entidades_item_id = item_dao.get_items_esquema(request.GET.get('esquema'))
for item in todas :
for entidad in entidades_item_id:
if item._id == entidad._id:
todas.remove(item)
entidades_item_id = todas
else:
entidades_item_id = item_dao.get_items_esquema(request.GET.get('esquema'))
elif request.GET.get('tipo') == "ELIMINADO":
entidades_item_id = item_dao.get_items_eliminados(fase_id)
elif request.GET.get('tipo') == "VERSIONES":
entidades_item_id = item_dao.get_items_por_version(request.GET.get("item_id"))
elif fase_id == None:
return Response(json.dumps({'sucess': 'true', 'lista':[]}))
else:
entidades_item_id = item_dao.get_items_fase(fase_id);
lista = [];
p = Pickler(True, None)
for entidad in entidades_item_id:
rd = ItemDAO(request)
padre = rd.get_by_id(entidad._padre_item_id)
antecesor = rd.get_by_id(entidad._antecesor_item_id)
entidadLinda = ItemDTO(entidad)
if padre != None:
entidadLinda._padre = ItemDTO(padre)
if antecesor != None:
entidadLinda._antecesor = ItemDTO(antecesor)
lista.append(p.flatten(entidadLinda))
j_string = p.flatten(lista)
a_ret = json.dumps({'sucess': True, 'lista':j_string})
return Response(a_ret)
elif (request.method == 'POST'):
u = Unpickler()
entidad = u.restore(request.json_body);
dao_fase = FaseDAO(request)
fase = dao_fase.get_by_id(entidad["_fase"])
if entidad['_tipo_item'] == '':
return Response(json.dumps({'sucess': 'false', 'message':'Debe seleccionar un Tipo de Item para guardar'}))
dao_tipo_item = TipoItemDAO(request)
tipo_item = dao_tipo_item.get_by_id(entidad["_tipo_item"]["_id"])
dao_item_ante = ItemDAO(request)
if(entidad["_antecesor"] == "" or entidad["_antecesor"] == None):
antecesor = None
antecesor_id = None
else:
antecesor = dao_item_ante.get_by_id(entidad["_antecesor"])
antecesor_id = antecesor._id
dao_item_padre = ItemDAO(request)
if(entidad["_padre"] == "" or entidad["_padre"] == None):
padre = None
padre_id = None
else:
padre = dao_item_padre.get_by_id(entidad["_padre"])
padre_id = padre._id
seq = Sequence('item_id_seq')
item_id = DBSession.execute(seq)
if entidad["_fecha_inicio"]!= None and len(entidad["_fecha_inicio"])>1:
if entidad["_fecha_inicio"].find("T")>=0:
formato_entrada = "%Y-%m-%dT%H:%M:%S"
fecha_inicio = datetime.datetime.strptime(entidad["_fecha_inicio"],formato_entrada)
else:
formato_entrada = "%Y-%m-%d %H:%M:%S"
fecha_inicio = datetime.datetime.strptime(entidad["_fecha_inicio"],formato_entrada)
else:
fecha_inicio = ""
if padre != None and fecha_inicio != "":
if len(padre._fecha_inicio) > 1:
if padre._fecha_inicio.find("T")>=0:
formato_entrada = "%Y-%m-%dT%H:%M:%S"
else:
formato_entrada = "%Y-%m-%d %H:%M:%S"
padre_inicio = datetime.datetime.strptime(padre._fecha_inicio, formato_entrada)
if fecha_inicio < padre_inicio:
return Response(json.dumps({'sucess': 'false', 'message':'La fecha es menor a la fecha de inicio del padre'}))
if antecesor != None and fecha_inicio != "":
if len(antecesor._fecha_inicio)>1:
if antecesor._fecha_inicio.find("T")>=0:
formato_entrada = "%Y-%m-%dT%H:%M:%S"
else:
formato_entrada = "%Y-%m-%d %H:%M:%S"
antecesor_inicio = datetime.datetime.strptime(antecesor._fecha_inicio, formato_entrada)
if fecha_inicio < antecesor_inicio:
return Response(json.dumps({'sucess': 'false', 'message':'La fecha es menor a la fecha de inicio del antecesor'}))
nuevo_item = Item(item_id, entidad["_nombre"], tipo_item, fase, entidad["_duracion"], entidad["_descripcion"], entidad["_condicionado"], entidad["_version"], entidad["_estado"], fecha_inicio, entidad["_completado"], padre_id, antecesor_id, entidad["_color"])
itemDao = ItemDAO(request)
itemDao.crear(nuevo_item)
itemDao.actualizarEstadosFaseyProyecto(nuevo_item)
nuevo_item = ItemDTO(nuevo_item)
lista = []
p = Pickler()
lista.append(p.flatten(nuevo_item))
j_string = p.flatten(lista)
if (request.GET.get('actualizar') == "true"):
if (request.GET.get('rev') == True):
itemDao.actualizarReferenciasItemNuevaVersion(nuevo_item._id, entidad["_id"])
else:
itemDao.actualizarReferenciasItemNuevaVersion(nuevo_item._id)
return Response(json.dumps({'sucess': 'true', 'lista':j_string}))
def actualizarEstadosFaseyProyecto(self, item):
fase_dao = FaseDAO(self._request)
proyecto_dao = ProyectoDAO(self._request)
fase = fase_dao.get_by_id(item._fase_id)
proyecto = proyecto_dao.get_by_id(fase._proyecto_id)
if item._estado == 'ACTIVO':
items_fase = self.get_items_fase(fase._id)
cambiar = True
for item_fase in items_fase:
if item_fase._estado == 'REVISION' or item_fase._estado == 'COMPROMETIDO':
cambiar = False
if (cambiar == True):
if fase._estado != 'ACTIVA':
fase_dao.update_estado_entidad(fase._id, 'ACTIVA')
if proyecto._estado != 'ACTIVO':
proyecto_dao.update_estado_entidad(proyecto._id, 'ACTIVO')
elif item._estado == 'REVISION' or item._estado == 'COMPROMETIDO':
if fase._estado != 'COMPROMETIDA':
fase_dao.update_estado_entidad(fase._id, 'COMPROMETIDA')
if proyecto._estado != 'COMPROMETIDO':
proyecto_dao.update_estado_entidad(proyecto._id,
'COMPROMETIDO')
elif item._estado == 'BLOQUEADO' or item._estado == 'APROBADO':
items_fase = self.get_items_fase(fase._id)
cambiarFinalizado = 0
cambiarActivo = 0
for item_fase in items_fase:
if item_fase._estado == 'BLOQUEADO' or item_fase._estado == 'APROBADO':
cambiarFinalizado += 1
if item_fase._estado == 'ACTIVO' or item_fase._estado == 'APROBADO':
cambiarActivo += 1
if (cambiarFinalizado == len(items_fase)):
if fase._estado != 'FINALIZADA':
fase_dao.update_estado_entidad(fase._id, 'FINALIZADA')
if proyecto._estado != 'FINALIZADO':
proyecto_dao.update_estado_entidad(proyecto._id,
'FINALIZADO')
return
if (cambiarActivo == len(items_fase)):
if fase._estado != 'ACTIVA':
fase_dao.update_estado_entidad(fase._id, 'ACTIVA')
if proyecto._estado != 'ACTIVO':
proyecto_dao.update_estado_entidad(proyecto._id, 'ACTIVO')