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 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 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 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 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 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 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_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 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 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 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 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 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 mebasedict_handle(obj):
data = {}
j = Pickler(True, 100)
for k in obj.keys():
data[k] = j.flatten(obj[k])
return data
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 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 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_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 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 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_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 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 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 create_tipo(request):
if (request.method == 'POST'):
u = Unpickler()
entidad = u.restore(request.json_body);
tipoItemDao = TipoItemDAO(request);
proyectoDao = ProyectoDAO(request)
proyecto = proyectoDao.get_by_id(entidad["_proyecto_id"])
topos_tipos = tipoItemDao.get_query().filter(TipoItem._proyecto_id == entidad["_proyecto_id"]).all()
for tipo in topos_tipos:
if tipo._prefijo == entidad["_prefijo"]:
return Response(json.dumps({'sucess': 'false' , 'lista':'Prefijo ya Asignado'}))
nueva_entidad = TipoItem(entidad["_nombre"], entidad["_comentario"], entidad["_color"], entidad["_prefijo"], entidad["_condicionado"],proyecto)
tipoItemDao.crear(nueva_entidad);
lista = []
p = Pickler()
a = TipoItemDTO(nueva_entidad)
lista.append(p.flatten(a))
j_string = p.flatten(lista)
return Response(json.dumps({'sucess': 'true' , 'lista':j_string}))
def update_proyectos(request):
"""
@summary: Maneja las solicitudes para actualizacion de proyectos.
@param request: Solicitud de modificacion.
@return: Retorna el proyecto modificado.
"""
u = Unpickler()
dao = ProyectoDAO(request)
entidad = u.restore(request.json_body)
vieja = dao.get_by_id(entidad["id"])
vieja._nombre = entidad["_nombre"]
rol_dao = RolFinalDAO(request)
# if (isinstance(entidad["_autor"], dict)):
# rol = rol_dao.get_query().filter(RolFinal._id == entidad["_autor"]["_id"]).first()
# else:
rol = rol_dao.get_query().filter(
RolFinal._id == entidad["_autor_id"]).first()
vieja._autor = rol
vieja._prioridad = entidad["_prioridad"]
vieja._estado = entidad["_estado"]
lider_dao = RolFinalDAO(request)
# if (isinstance(entidad["_lider"], dict)):
# lider = lider_dao.get_query().filter(RolFinal._id == entidad["_lider"]["_id"]).first()
# else:
lider = lider_dao.get_query().filter(
RolFinal._id == entidad["_lider_id"]).first()
vieja._lider = lider
vieja._nota = entidad["_nota"]
vieja._fecha_creacion = entidad["_fecha_creacion"]
vieja._fecha_modificacion = entidad["_fecha_modificacion"]
asignar_permiso_rol_proyecto(request, vieja._autor, vieja)
asignar_permiso_rol_proyecto(request, vieja._lider, vieja)
dao.update(vieja)
lista = []
p = Pickler()
a = ProyectoDTO(vieja)
lista.append(p.flatten(a))
j_string = p.flatten(lista)
return Response(json.dumps({'sucess': 'true', 'proyectos': j_string}))
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 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
