def mebasedict_handle(obj):
data = {}
j = Pickler(True, 100)
for k in obj.keys():
data[k] = j.flatten(obj[k])
return data
def obtener_permisos(request):
user = request.session['user']
r = RolDAO(request)
rol = r.get_by_id(user._id)
rd = PermisosRolesDAO(request)
if request.GET.get('id') != None:
permisos = rd.get_query().filter(
PermisosRoles._rol_id == request.GET.get('id')).order_by(
PermisosRoles._permiso_id.asc()).all()
else:
permisos = get_permisos_rol(request, rol, [], rd, [], r)
lista = []
p = Pickler()
for permiso in permisos:
a = PermisoRolDTO(permiso)
a._rol = rol
lista.append(p.flatten(a))
j_string = p.flatten(lista)
a_ret = json.dumps({'sucess': 'true', 'permisos': j_string})
return Response(a_ret)
def actualizar_eliminar_atributofase(request):
"""
@summary: Maneja las solicitudes para actualizar y elimninar atributos particulares de una fase.
@param request: Delete para eliminar y Put para modificar.
@return: En caso de recibir un Put retorna el atributo particular modificado.
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 = AtributoFaseDAO(request)
atributo = dao.get_by_id(entidad["id"])
dao.borrar(atributo)
return Response(json.dumps({'sucess': 'true'}))
else:
#recibio un put
u = Unpickler()
dao = AtributoFaseDAO(request)
entidad = u.restore(request.json_body);
vieja = dao.get_by_id(entidad["id"])
vieja._nombre = entidad["_nombre"]
vieja._descripcion = entidad["_descripcion"]
vieja._valor = entidad["_valor"]
dao.update(vieja)
lista = []
p = Pickler()
lista.append(p.flatten(vieja))
j_string = p.flatten(lista)
return Response(json.dumps({'sucess': 'true', 'atributofase':j_string}))
def permisos_rest(request):
if request.method == "POST":
u = Unpickler()
objeto = u.restore(request.json_body)
permiso_dao = PermisosDAO(request)
id_permiso = objeto["_permiso"]
permiso = permiso_dao.get_by_id(id_permiso)
rol_dao = RolDAO(request)
id_rol = objeto["_rol"]
rol = rol_dao.get_by_id(id_rol)
objeto = PermisosRoles(permiso, rol)
dao = PermisosRolesDAO(request)
dao.crear(objeto)
dto = PermisoRolDTO(objeto)
p = Pickler()
aRet = p.flatten(dto)
return Response(json.dumps({'sucess': 'true', 'permisos': aRet}))
if request.method == "DELETE":
id = request.matchdict['id']
dao = PermisosRolesDAO(request)
entidad = dao.get_by_id(id)
dao.borrar(entidad)
return Response(json.dumps({'sucess': 'true'}))
return ""
def encode(value, unpicklable=True, max_depth=None):
"""
Return a JSON formatted representation of value, a Python object.
The keyword argument 'unpicklable' defaults to True.
If set to False, the output will not contain the information
necessary to turn the JSON data back into Python objects.
The keyword argument 'max_depth' defaults to None.
If set to a non-negative integer then jsonpickle will not recurse
deeper than 'max_depth' steps into the object. Anything deeper
than 'max_depth' is represented using a Python repr() of the object.
>>> encode('my string')
'"my string"'
>>> encode(36)
'36'
>>> encode({'foo': True})
'{"foo": true}'
>>> encode({'foo': True}, max_depth=0)
'"{\\'foo\\': True}"'
>>> encode({'foo': True}, max_depth=1)
'{"foo": "True"}'
"""
j = Pickler(unpicklable=unpicklable, max_depth=max_depth)
return json.encode(j.flatten(value))
def encode(value, unpicklable=True, max_depth=None):
"""
Return a JSON formatted representation of value, a Python object.
The keyword argument 'unpicklable' defaults to True.
If set to False, the output will not contain the information
necessary to turn the JSON data back into Python objects.
The keyword argument 'max_depth' defaults to None.
If set to a non-negative integer then jsonpickle will not recurse
deeper than 'max_depth' steps into the object. Anything deeper
than 'max_depth' is represented using a Python repr() of the object.
>>> encode('my string')
'"my string"'
>>> encode(36)
'36'
>>> encode({'foo': True})
'{"foo": true}'
>>> encode({'foo': True}, max_depth=0)
'"{\\'foo\\': True}"'
>>> encode({'foo': True}, max_depth=1)
'{"foo": "True"}'
"""
j = Pickler(unpicklable=unpicklable,
max_depth=max_depth)
return json.encode(j.flatten(value))
def http_response(self):
pickler = Pickler(unpicklable=False)
info_dict = pickler.flatten(self)
del(info_dict['error_code'])
main_response_dict = {'error_code' : self.error_code,
'info' : info_dict }
json_string = jsonpickle.encode(main_response_dict, unpicklable=False)
return HttpResponse(content=json_string, mimetype="application/json")
def get_proyectos(request):
proyectoDAO = ProyectoDAO(request);
entidades = proyectoDAO.get_all();
p = Pickler();
lista = [];
for entidad in entidades:
lista.append(p.flatten(ProyectoDTO(entidad)));
j_string = p.flatten(lista)
a_ret = json.dumps({'sucess': 'true', 'entidades':j_string})
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 get_esquemas(request):
dao = EsquemaDAO(request);
entidades = dao.get_all();
p = Pickler();
lista = [];
for entidad in entidades:
lista.append(p.flatten(entidad));
j_string = p.flatten(lista)
a_ret = json.dumps({'sucess': 'true', 'entidades':j_string})
return Response(a_ret)
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_all_permisos(request):
permisos_dao = PermisosDAO(request)
permisos = permisos_dao.get_query().all()
p = Pickler()
lista = []
for permiso in permisos:
a = PermisoDTO(permiso)
lista.append(p.flatten(a))
j_string = p.flatten(lista)
a_ret = json.dumps({'sucess': 'true', 'permisos': j_string})
return Response(a_ret)
def actualizar_eliminar_unidad_trabajo(request):
"""
@summary: Maneja las solicitudes para eliminar y actualizar unidades de trabajo.
@param request: Delete para eliminar y Put para modificar.
@return: Retorna la unidad de trabajo modificada en caso de recibir un Put.
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 = UnidadTrabajoDAO(request)
unidad = dao.get_by_id(entidad["id"])
id_unidad = entidad['id']
unidad_item_dao = ItemUnidadDAO(request)
items = unidad_item_dao.get_query().filter(ItemUnidadTrabajo._unidad_id == id_unidad).first()
if items != None:
return Response(json.dumps({'sucess': 'false' , "message": "La unidad de trabajo no se puede eliminar,debido a que esta asignado a un item" }))
dao_unidad_recurso = UnidadTrabajoRecursoDAO(request)
entidades = dao_unidad_recurso.get_query().filter(UnidadTrabajo_Recurso._unidad_trabajo_id==id_unidad).all();
for unidad_recurso in entidades:
dao_unidad_recurso.borrar(unidad_recurso)
dao.borrar(unidad)
return Response(json.dumps({'sucess': 'true'}))
else:
#Recibio un Put
u= Unpickler()
dao = UnidadTrabajoDAO(request)
entidad = u.restore(request.json_body);
unidad_item_dao = ItemUnidadDAO(request)
items = unidad_item_dao.get_query().filter(ItemUnidadTrabajo._unidad_id == entidad["id"]).first()
if items != None:
return Response(json.dumps({'sucess': 'false' , "message": "La unidad de trabajo no se puede modificar,debido a que esta asignado a un item" }))
vieja = dao.get_by_id(entidad["id"])
vieja._nombre = entidad["_nombre"]
vieja._etiqueta = entidad["_etiqueta"]
vieja._descripcion = entidad["_descripcion"]
vieja._color = entidad["_color"]
dao.update(vieja)
lista = []
p = Pickler()
lista.append(p.flatten(vieja))
j_string = p.flatten(lista)
a_ret = json.dumps({'sucess': 'true', 'unidadtrabajo':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 get_con_fase(request):
dao = LineaBaseDAO(request)
entidades = dao.get_query().filter(
LineaBase._fase_id == request.GET.get('id_fase')).all()
lista = []
p = Pickler(False, None)
for entidad in entidades:
dto = LineaBaseDTO(entidad)
lista.append(p.flatten(dto))
j_string = p.flatten(lista)
a_ret = json.dumps({'sucess': 'true', 'entidades': j_string})
return Response(a_ret)
def put_suscripcion(request):
u = Unpickler()
objeto = u.restore(request.json_body)
dao = SuscripcionDAO(request)
entidad = get_entidad_padre(request, objeto)
rol = get_rol_final(request, objeto)
a_editar = dao.get_by_id(request.matchdict['id_suscripcion'])
a_editar._nombre = objeto['_nombre']
a_editar._entidad_padre = entidad
a_editar._rol = rol
dao.update(a_editar)
p = Pickler()
aRet = p.flatten(entidad)
return Response(json.dumps({'sucess': 'true'}))
def AG_esquemas(request):
if (request.method == 'GET'):
rd = EsquemaDAO(request)
fase_id = request.GET.get('id')
entidades = rd.get_query().filter(Esquema._fase_id == fase_id).all()
lista = []
p = Pickler(True, None)
# val = Validador(request);
for entidad in entidades:
# if val.es_visible(entidad):
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)
esquemaDao = EsquemaDAO(request)
nueva_entidad = Esquema(entidad["_nombre"], entidad["_descripcion"],
entidad["_etiqueta"], entidad["_color"],
entidad["_fase_id"])
esquemaDao.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_notificaciones(request):
id_suscripcion = request.GET.get('id')
dao = NotificacionDAO(request)
entidades = dao.get_query().filter(
Notificacion._suscripcion_id == id_suscripcion,
Notificacion._leido == False).all()
lista = []
p = Pickler(False, None)
for notificacion in entidades:
dto = HistorialDTO(notificacion._historial)
lista.append(p.flatten(dto))
j_string = p.flatten(lista)
a_ret = json.dumps({'sucess': 'true', 'lista': j_string})
return Response(a_ret)
def AG_atributos(request):
if (request.method == 'GET'):
rd = AtributoEsquemaDAO(request)
esquema_id = request.GET.get('id')
entidades = rd.get_query().filter(
AtributoEsquema._esquema_id == esquema_id).all()
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)
atributoEsquemaDao = AtributoEsquemaDAO(request)
nueva_entidad = AtributoEsquema(entidad["_nombre"],
entidad["_descripcion"],
entidad["_tipo"], entidad["_valor"],
entidad["_esquema_id"])
atributoEsquemaDao.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 AG_item_esquema(request):
if (request.method == 'GET'):
rd = EsquemaItemDAO(request)
esquema_id = request.GET.get('id')
entidades = rd.get_query().filter(
EsquemaItem._esquema_id == esquema_id).all()
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)
esquemaItemDao = EsquemaItemDAO(request)
nueva_entidad = EsquemaItem(entidad["_esquema_id"],
entidad["_item_id"])
esquemaItemDao.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 retornador_de_roles(request, entidades):
lista = []
p = Pickler(False, None)
for entidad in entidades:
rol = RolDTO(entidad)
if (isinstance(entidad, RolFinal)):
rol._esFinal = True
rol._password = entidad._password
rol._email = entidad._email
lista.append(p.flatten(rol))
j_string = p.flatten(lista)
a_ret = json.dumps({'sucess': 'true', 'users': j_string})
return Response(a_ret)
def get_estado_roles(request):
"""Metodo que maneja las llamadas para estados de roles
- Retorna una lista si se envia GET
"""
# if (request.method == 'GET'):
re = RolEstadoDAO(request)
entidades = re.get_query().all()
lista = []
p = Pickler()
for entidad in entidades:
lista.append(p.flatten(entidad))
j_string = p.flatten(lista)
a_ret = json.dumps({'sucess': 'true', 'estados': j_string})
return Response(a_ret)
def get_entidades(request):
"""Metodo que maneja las llamadas para entidades
- Retorna una lista si se envia GET
"""
if (request.method == 'GET'):
dao = PrivilegioDAO(request)
entidades = dao.get_all()
lista = []
p = Pickler()
for objeto in entidades:
epDAO = PrivilegioDTO(objeto)
lista.append(p.flatten(epDAO))
j_string = p.flatten(lista)
a_ret = json.dumps({'sucess': 'true', 'entidades': j_string})
return Response(a_ret)
def get_roles_finales(request):
dao = RolFinalDAO(request)
entidades = dao.get_all()
lista = []
p = Pickler(False, None)
for entidad in entidades:
rol = RolDTO(entidad)
if (isinstance(entidad, RolFinal)):
rol._esFinal = True
rol._password = entidad._password
rol._email = entidad._email
lista.append(p.flatten(rol))
j_string = p.flatten(lista)
a_ret = json.dumps({'sucess': 'true', 'users': j_string})
return Response(a_ret)
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 eliminar_suscripcion(request, id):
"""B{Metodo que elimina una suscripcion}
- B{Parametros:}
- B{Request:} peticion enviada por el navegador
- B{ID:} id de la suscripcion a eliminar
- B{Retorna:}
- B{JSON:} Json compuesto, por un boolean B{sucess}
con el estado de la operacion y B{suscrpciones} un json de suscripciones.
"""
dao = SuscripcionDAO(request)
entidad = dao.get_by_id(id)
dao.borrar(entidad)
lista = []
p = Pickler()
j_string = p.flatten(entidad)
a_ret = json.dumps({'sucess': 'true', 'suscripciones': j_string})
return Response(a_ret)
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 post_suscripcion(request):
u = Unpickler()
objeto = u.restore(request.json_body)
dao = SuscripcionDAO(request)
if objeto['_entidad_padre'] == None:
entidad_padre = None
else:
entidad_padre = EntidadPadreDAO(request).get_by_id(
objeto['_entidad_padre'])
if objeto['_rol_final'] == None:
rol = None
else:
rol = RolFinalDAO(request).get_by_id(objeto['_rol_final'])
entidad = Suscripcion(objeto['_nombre'], entidad_padre, rol)
dao.crear(entidad)
p = Pickler()
aRet = p.flatten(entidad)
return Response(json.dumps({'sucess': 'true', 'suscripciones': aRet}))
def get_archivos(request):
item_id = request.GET.get('_item_id')
if (item_id == None):
a_ret = json.dumps({'sucess': True, 'archivos':[]})
return Response(a_ret)
dao = ItemArchivoDAO(request)
entidades = dao.get_query().filter(ItemArchivo._item_id == item_id).all()
lista = [];
# p = Pickler(True, None)
p = Pickler()
archivo_dao = ArchivoDAO(request)
for entidad in entidades:
a = archivo_dao.get_by_id(entidad._archivo_id)
b = ArchivoDTO(a)
lista.append(p.flatten(b))
j_string = p.flatten(lista)
a_ret = json.dumps({'sucess': True, 'archivos':j_string})
return Response(a_ret)
def get_entidades(request):
"""B{Metodo que retorna una lista de suscripciones}
- B{Parametros:}
- B{Request:} peticion enviada por el navegador
- B{Retorna:}
- B{JSON:} Json compuesto, por un boolean B{sucess}
con el estado de la operacion y B{suscripciones} un json de suscripciones.
"""
dao = EntidadPadreDAO(request)
entidades = dao.get_all()
lista = [];
p = Pickler()
for entidad in entidades:
lista.append(p.flatten(entidad))
j_string = p.flatten(lista)
a_ret = json.dumps({'sucess': 'true', 'entidades':j_string})
return Response(a_ret)
def update_tipo(request):
u = Unpickler()
entidad = u.restore(request.json_body);
tipoItemDao = TipoItemDAO(request);
tipoItem = tipoItemDao.get_by_id(entidad["id"])
if (isinstance(tipoItem, TipoItem)):
tipoItem._nombre = entidad["_nombre"]
tipoItem._comentario = entidad["_comentario"]
tipoItem._color = entidad["_color"]
tipoItem._prefijo = entidad["_prefijo"]
tipoItem._condicionado = entidad["_condicionado"]
tipoItemDao.update(tipoItem);
lista = []
p = Pickler()
a = TipoItemDTO(tipoItem)
lista.append(p.flatten(a))
j_string = p.flatten(lista)
return Response(json.dumps({'sucess': 'true', 'lista':j_string}))
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 mebaselist_handle(obj):
ret = []
j = Pickler(False, 100)
return [j.flatten(i) for i in obj]
def flatten(self, obj, data = {}):
j = Pickler(False, 100)
for k in obj.__getstate__().keys():
data[k] = j.flatten(obj[k])
return data
