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 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 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 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 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 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 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 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 get_privilegios(request):
"""Metodo que maneja las llamadas para privilegios
- Retorna una lista si se envia GET
- Agrega si se envia POST
- Modifica si se envia PUT
- Elimina si se envia DELETE
"""
if (request.method == 'GET'):
id_rol = request.GET.get('id_rol')
dao = RolPrivilegioDAO(request)
entidades = dao.get_query().filter(
RolPrivilegio._rol_id == id_rol).all()
lista = []
p = Pickler()
for entidad in entidades:
n_entidad = RolPrivilegioDTO(entidad)
lista.append(p.flatten(n_entidad))
j_string = p.flatten(lista)
a_ret = json.dumps({'sucess': 'true', 'privilegios': j_string})
return Response(a_ret)
if (request.method == 'POST'):
u = Unpickler()
#{"id":0,"_entidad":1,"_privilegio":1,"_permitir":true,"_rol":2}
objeto = u.restore(request.json_body)
if (objeto['_entidad'] == ''):
entidad = None
else:
entidad = EntidadPadreDAO(request).get_by_id(objeto['_entidad'])
privilegio = PrivilegioDAO(request).get_by_id(objeto['_privilegio'])
rol = RolDAO(request).get_by_id(objeto['_rol'])
nuevo = RolPrivilegio(privilegio, entidad, rol, objeto['_permitir'])
dao = RolPrivilegioDAO(request)
dao.crear(nuevo)
p = Pickler()
aRet = p.flatten(nuevo)
return Response(json.dumps({'sucess': 'true', 'privilegios': aRet}))
if (request.method == 'DELETE'):
id_privilegio = request.matchdict['id_privilegio']
dao = RolPrivilegioDAO(request)
entidad = dao.get_by_id(id_privilegio)
dao.borrar(entidad)
return Response(json.dumps({'sucess': 'true'}))
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_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_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_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 main(argv):
if len(argv) != 2:
print('error: usage: {} [shelvefile]'.format(basename(argv[0])))
return 1
if not exists(sys.argv[1]):
print('error: file does not exist: {}'.format(sys.argv[1]))
return 2
shelf = shelve.open(sys.argv[1])
print(json.dumps(Pickler().flatten(dict(shelf)), indent=2))
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 __init__(self,
url,
serverTimeout=5.0,
pickler=Pickler(max_depth=4, max_iter=100, make_refs=False)):
self.wsClient = WSHubsAPIClient(self, url, serverTimeout)
self.pickler = pickler
self.SyncHub = self.__SyncHub(self.wsClient, self.pickler)
self.TaskHub = self.__TaskHub(self.wsClient, self.pickler)
self.UtilsHub = self.__UtilsHub(self.wsClient, self.pickler)
self.PlaceHub = self.__PlaceHub(self.wsClient, self.pickler)
self.UserHub = self.__UserHub(self.wsClient, self.pickler)
self.LoginHub = self.__LoginHub(self.wsClient, self.pickler)
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 __create_dict(store_item: object) -> Dict:
"""Return the dict of an object.
This eliminates non_magic attributes and the e_tag.
:param store_item:
:return dict:
"""
# read the content
json_dict = Pickler().flatten(store_item)
if "e_tag" in json_dict:
del json_dict["e_tag"]
return json_dict
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 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 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 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)
