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 calcular_impacto(request):
id_item = request.GET.get("id")
item_dao = ItemDAO(request)
item = item_dao.get_by_id(id_item);
impacto = CalculoImpacto(item, request);
p = Pickler(False, None)
# ret_json = p.flatten(CalculoImpactoDTO(item, antecesores, None))
ret_json = p.flatten(impacto.calculo_impacto())
a_ret = json.dumps({'sucess': 'true', 'impacto':ret_json})
return Response(a_ret)
def get_items(request):
dao = ItemDAO(request)
entidades = dao.get_items_globales();
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 __init__(self, item, request):
self.item = item
self.dao = ItemDAO(request);
self.linea_base_dao = LineaBaseDAO(request)
self.item_unidad_dao = ItemUnidadDAO(request)
self.unidad_recurso_dao = UnidadTrabajoRecursoDAO(request)
self.recurso_dao = RecursoDAO(request)
self.antecesores = []
self.sucesores = []
self.request = request
self.item.calculado = True
self.revisados_atras = []
self.revisados_adelante = []
self.revisados = []
def get_items_con_linea_base(request):
rd = ItemDAO(request)
linea_base_id = request.GET.get('id_linea_base')
entidades = rd.get_query().filter(Item._linea_base_id == linea_base_id).all()
lista = [];
p = Pickler(True, None)
for entidad in entidades:
rd = ItemDAO(request)
# padre = rd.get_by_id(entidad._padre_item_id)
# antecesor = rd.get_by_id(entidad._antecesor_item_id)
entidadLinda = ItemDTO(entidad)
# entidadLinda = ItemLindo(entidad._id, entidad._nombre, entidad._tipo_item, entidad._fase, entidad._duracion, entidad._descripcion, entidad._condicionado, entidad._version, entidad._estado, entidad._fecha_inicio, entidad._fecha_fin, padre, antecesor)
lista.append(p.flatten(entidadLinda))
j_string = p.flatten(lista)
a_ret = json.dumps({'sucess': True, 'lista':j_string})
return Response(a_ret)
def AG_atributos_tipos_item(request):
if (request.method == 'GET'):
if request.GET.get('_item_id') != None:
item_id = request.GET.get('_item_id');
itemDAO = ItemDAO(request)
item = itemDAO.get_ultima_version_item_by_id(item_id);
atributoTipoItemDAO = AtributoTipoItemDAO(request)
atributosTipoItem = atributoTipoItemDAO.get_atributos_by_tipo_id(item._tipo_item_id)
dao = ItemAtributoDAO(request)
entidades = dao.get_query().filter(ItemAtributo._item_id == item._id).all()
p = Pickler()
aRet = []
aRet = atributosTipoItem
if (request.GET.get('_no_definidos') == "true"):
for ent in entidades:
for atributo in atributosTipoItem:
if ent._atributo_id == atributo._id:
aRet.remove(atributo);
entidades = aRet
else:
rd = AtributoTipoItemDAO(request)
entidades = rd.get_atributos_by_tipo_id(request.GET.get('id'))
lista = [];
p = Pickler(True, None)
for entidad in entidades:
lista.append(p.flatten(entidad))
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);
atributoItemDao = AtributoTipoItemDAO(request);
nueva_entidad = AtributoTipoItem(entidad["_tipo"], entidad["_valor"], entidad["_descripcion"], entidad["_opcional"], entidad["_defecto"], entidad["_tipo_item_id"])
atributoItemDao.crear(nueva_entidad);
lista = []
p = Pickler()
lista.append(p.flatten(nueva_entidad))
j_string = p.flatten(lista)
return Response(json.dumps({'sucess': 'true', 'lista':j_string}))
def get_items_sin_linea_base_con_fase(request):
rd = ItemDAO(request)
linea_base_id = request.GET.get('id_linea_base')
fase_id = request.GET.get('id')
entidades = rd.get_items_aprobados(fase_id);
# entidades = rd.get_query().filter(Item._linea_base_id == None, Item._fase_id == fase_id).all()
lista = [];
p = Pickler(True, None)
for entidad in entidades:
if entidad._linea_base_id != None:
continue;
rd = ItemDAO(request)
# padre = rd.get_by_id(entidad._padre_item_id)
# antecesor = rd.get_by_id(entidad._antecesor_item_id)
entidadLinda = ItemDTO(entidad)
lista.append(p.flatten(entidadLinda))
j_string = p.flatten(lista)
a_ret = json.dumps({'sucess': True, 'lista':j_string})
return Response(a_ret)
def obtener_crear_unidad_trabajo(request):
"""
@summary: Maneja las solicitudes para obtener y crear unidad de trabajo.
@param request: Get para recuperar y Post para crear.
@return: Retorna todos las unidades de trabajo en caso de recibir un Get.
Retorna la unidad creada en caso de recibir una unidad de trabajo
"""
if (request.method == 'GET'):
rd = UnidadTrabajoDAO(request)
unidades = [];
unidades = rd.get_all()
item_id = request.GET.get('_item_id')
# print item_id
if (item_id !=None):
item_dao = ItemDAO(request)
# unidades = item_dao.get_unidades_disponibles(item_dao.get_by_id(item_id))
#####################################
###La parte comentada de abajo, trae las unidades como le gusta a cocho,
###osea, con ese return se podra asignar a cualquier item la misma unidad de trabajo
###si es que ya no tiene una asignada
#####################################
itemUnidadDao = ItemUnidadDAO(request)
unidadesAsignadas = itemUnidadDao.get_query().filter(ItemUnidadTrabajo._item_id == item_id).all()
for unidadAsignada in unidadesAsignadas:
for unidad in unidades:
if (unidad._id == unidadAsignada._unidad_id):
unidades.remove(unidad)
lista = [];
p = Pickler()
for entidad in unidades:
lista.append(p.flatten(entidad))
j_string = p.flatten(lista)
a_ret = json.dumps({'sucess': 'true', 'unidadtrabajo':j_string})
return Response(a_ret)
else:
#Recibio un Post
u= Unpickler()
entidad = u.restore(request.json_body);
nueva_unidad_trabajo = UnidadTrabajo(entidad["_nombre"],entidad["_etiqueta"],entidad["_descripcion"],entidad["_color"])
dao = UnidadTrabajoDAO(request)
dao.crear(nueva_unidad_trabajo)
lista = []
p = Pickler()
lista.append(p.flatten(nueva_unidad_trabajo))
j_string = p.flatten(lista)
a_ret = json.dumps({'sucess': 'true', 'unidadtrabajo':j_string})
return Response(a_ret)
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 upload(request):
id_item = request.params['id_item'],
archivo = request.params['archivo'].file.read()
nombre = request.params['archivo'].filename
archivo_dao = ArchivoDAO(request)
nuevo_archivo = Archivo(archivo, nombre)
archivo_dao.crear(nuevo_archivo)
item_dao = ItemDAO(request)
item = item_dao.get_by_id(id_item)
item_archivo_dao = ItemArchivoDAO(request)
nuevo_item_archivo = ItemArchivo(item, nuevo_archivo)
item_archivo_dao.crear(nuevo_item_archivo)
# response= Response(content_type='application/force-download',content_disposition='attachment; filename=' + nuevo_archivo._nombre)
# response.app_iter= nuevo_archivo._contenido
# return response
item_dao.actualizarReferenciasItemNuevaVersion(id_item)
return Response(json.dumps({'success': True}))
def editar_atributo_item(request):
if (request.method == 'PUT'):
u = Unpickler()
entidad = u.restore(request.json_body);
dao = ItemAtributoDAO(request)
item_atributo = dao.get_by_id(entidad["id"])
item_dao = ItemDAO(request)
item_atributo._valor = entidad["_valor"]
dao.update(item_atributo);
return Response(json.dumps({'sucess': 'true'}))
elif (request.method == 'DELETE'):
u = Unpickler()
entidad = u.restore(request.json_body);
dao = ItemAtributoDAO(request)
item_unidad = dao.get_by_id(entidad["id"])
dao.borrar(item_unidad)
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'}))
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'}))
if (request.method == "DELETE"):
try:
id_linea_base = request.matchdict['id']
item_dao = ItemDAO(request)
romper_linea_base(request, id_linea_base, item_dao)
return Response(json.dumps({'sucess': 'true'}))
except FaseNoEncontradaException, e:
print e
return Response(json.dumps({'sucess': 'false'}))
return Response(json.dumps({'sucess': 'false'}))
def romper_linea_base(request, id_linea_base, item_dao, estado="APROBADO"):
dao = LineaBaseDAO(request)
entidad = dao.get_by_id(id_linea_base)
if entidad == None:
return
bases_afectadas = []
for item in entidad._items:
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 guardar_obtener_atributo(request):
if (request.method == 'POST'):
u = Unpickler()
entidad = u.restore(request.json_body);
dao = ItemAtributoDAO(request)
item_dao = ItemDAO(request)
item = item_dao.get_by_id(entidad["_item_id"])
a_tipo_dao = AtributoTipoItemDAO(request)
asignacion = ItemAtributo(entidad["_item_id"], entidad["_atributo_id"], entidad["_valor"] )
dao.crear(asignacion);
asignacion._item = item
atributo = a_tipo_dao.get_by_id(entidad["_atributo_id"])
asignacion._atributo = atributo
asignacion = ItemAtributoDTO(asignacion)
p = Pickler(True, None)
aRet = p.flatten(asignacion)
item_dao.actualizarReferenciasItemNuevaVersion(item._id)
return Response(json.dumps({'sucess': 'true', 'lista':aRet}))
elif (request.method == 'GET'):
item_id = request.GET.get('_item_id');
p = Pickler(True, None)
if (item_id == 0 or item_id == "0" or item_id == None):
j_string = p.flatten([])
a_ret = json.dumps({'sucess': True, 'lista':j_string})
return Response(a_ret)
itemDAO = ItemDAO(request)
item = itemDAO.get_by_id(item_id);
atributoTipoItemDAO = AtributoTipoItemDAO(request)
atributosTipoItem = atributoTipoItemDAO.get_atributos_by_tipo_id(item._tipo_item_id)
# lista=[]
# for atributo in atributosTipoItem:
# dao = ItemAtributoDAO(request)
# actual = dao.get_query().filter(ItemAtributo._item_id == item.id , ItemAtributo._atributo_id == atributo._id).order_by(ItemAtributo._version.desc()).first();
# if actual != None:
# lista.append(actual)
# aRet = []
# if (len(lista)==0):
dao = ItemAtributoDAO(request)
entidades = dao.get_query().filter(ItemAtributo._item_id == item._id).all()
aRet = entidades
for atributov in atributosTipoItem:
if atributov._opcional == False:
itemAtributo = ItemAtributo(item.id , atributov._id, atributov._defecto)
# itemAtributo._item = item
# itemAtributo._atributo = atributo
# itemAtributoDTO = ItemAtributoDTO(itemAtributo)
if len(entidades)==0:
dao.crear(itemAtributo);
aRet.append(itemAtributo)
# else:
# for entidad in entidades:
# if (itemAtributo._atributo_id != entidad._atributo_id):
# aRet.append(itemAtributo)
entidadesDTO = [];
for entidad in aRet:
dao = AtributoTipoItemDAO(request)
atributo = dao.get_by_id(entidad._atributo_id)
entidad._item = item
entidad._atributo = atributo
itemAtributoDTO = ItemAtributoDTO(entidad);
entidadesDTO.append(itemAtributoDTO)
j_string = p.flatten(entidadesDTO)
a_ret = json.dumps({'sucess': True, 'lista':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}))
class CalculoImpacto:
def __init__(self, item, request):
self.item = item
self.dao = ItemDAO(request);
self.linea_base_dao = LineaBaseDAO(request)
self.item_unidad_dao = ItemUnidadDAO(request)
self.unidad_recurso_dao = UnidadTrabajoRecursoDAO(request)
self.recurso_dao = RecursoDAO(request)
self.antecesores = []
self.sucesores = []
self.request = request
self.item.calculado = True
self.revisados_atras = []
self.revisados_adelante = []
self.revisados = []
def imprimir_items(self, items):
for item in items:
print "\tITEM con NOMBRE: " + item._nombre
def calculo_impacto(self):
# self.calculo_impacto_atras(self.item)
# self.calculo_impacto_adelante(self.item)
self._calculo_impacto(self.item)
bases = self.verificar_lineas_base(self.antecesores, [])
bases = self.verificar_lineas_base(self.sucesores, bases)
bases = self.verificar_linea_base_item(self.item, bases)
costo_antecesores = self.calcular_costo_items(self.antecesores)
costo_sucesores = self.calcular_costo_items(self.sucesores)
return CalculoImpactoDTO(self.item, self.antecesores, self.sucesores, bases, costo_antecesores, costo_sucesores)
def verificar_lineas_base (self, items, bases):
for item in items:
item_fresco = self.dao.get_ultima_version_item_by_id(item._item_id)
linea = self.linea_base_dao.get_by_id(item_fresco._linea_base_id)
if linea != None and self._esta_adentro(linea, bases) == False:
bases.append(linea)
return bases
def verificar_linea_base_item(self, item, bases):
if item._linea_base_id == None:
return bases;
linea = self.linea_base_dao.get_by_id(item._linea_base_id)
if linea != None and self._esta_adentro(linea, bases) == False:
bases.append(linea)
return bases
def _calculo_impacto(self, item, lista=AUX_NADA):
if item == None:
return
if self._esta_adentro(item, self.revisados) == False:
self.revisados.append(item)
else:
return
#ATRAS
antecesor = self.get_item(item._antecesor_item_id)
if antecesor != None:
if lista == "":
self._calculo_impacto(antecesor, AUX_ATRAS)
if lista == AUX_ATRAS:
self._calculo_impacto(antecesor, lista)
padre = self.get_item(item._padre_item_id)
if padre != None:
if lista == AUX_NADA:
self._calculo_impacto(padre, AUX_ATRAS)
if lista == AUX_ATRAS:
self._calculo_impacto(padre, lista)
#ADELANTE
hijos = self.dao.get_query().filter(Item._padre_item_id == item._id).all()
for hijo in hijos:
hijo_ultima_version = self.dao.get_ultima_version_item_by_id(hijo._item_id)
if hijo_ultima_version._padre_item_id == item._id:
if lista == AUX_NADA:
self._calculo_impacto(hijo_ultima_version, AUX_SUCESOR)
if lista == AUX_SUCESOR :
self._calculo_impacto(hijo_ultima_version, lista)
sucesores = self.dao.get_query().filter(Item._antecesor_item_id == item._id).all()
for sucesor in sucesores:
sucesor_ultima_version = self.dao.get_ultima_version_item_by_id(sucesor._item_id)
if sucesor_ultima_version._antecesor_item_id == item._id:
if lista == AUX_NADA:
self._calculo_impacto(sucesor_ultima_version, AUX_SUCESOR)
if lista == AUX_SUCESOR:
self._calculo_impacto(sucesor_ultima_version, lista)
if lista == AUX_SUCESOR:
self.sucesores.append(item)
if lista == AUX_ATRAS:
self.antecesores.append(item)
def get_item(self, item_id):
if item_id == None:
return None
item_temporal = self.dao.get_by_id(item_id)
antecesor = self.dao.get_ultima_version_item_by_id(item_temporal._item_id)
return antecesor
def _esta_adentro(self, item, lista):
for entidad in lista:
if entidad._id == item._id:
return True;
return False
def calcular_costo_items(self, items):
costo = 0;
for item in items:
costo_item = self.costo_item(item)
item._costo = costo_item;
costo += costo_item;
return costo;
def costo_item(self, item):
items_unidades = self.item_unidad_dao.get_query().filter(ItemUnidadTrabajo._item_id == item._id).all();
costo = 0;
for item_unidad in items_unidades:
costo_unidad = self.costo_unidad(item_unidad._unidad_id)
costo += costo_unidad
return costo
def costo_unidad(self, unidad_id):
unidad_recursos = self.unidad_recurso_dao.get_query().filter(UnidadTrabajo_Recurso._unidad_trabajo_id == unidad_id).all()
costo = 0
for unidad_recurso in unidad_recursos:
recurso = self.recurso_dao.get_by_id(unidad_recurso._recurso_id)
costo += self.get_costo_recurso(recurso)
return costo
def get_costo_recurso(self, recurso):
if isinstance(recurso, RecursoPersona) :
return recurso._costo_hora
return recurso._costo_cantidad