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 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 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 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 asignar_recursos(request):
"""
@summary: Se encarga de asignar recursos a la unidad de trabajo.
@param request: La unidad de trabajo y los recursos.
"""
u= Unpickler()
entidad = u.restore(request.json_body);
id_unidad = entidad['id_unidad_trabajo']
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": "No se puede realizar la operacion debido a que la unidad de trabajo 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)
for id_recurso in entidad['_recursos']:
a_guardar = UnidadTrabajo_Recurso(id_unidad, id_recurso)
dao_unidad_recurso.crear(a_guardar)
a_ret = json.dumps({'sucess': 'true', 'recursos': entidad})
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 decode(string):
"""Converts the JSON string into a Python object.
>>> str(decode('"my string"'))
'my string'
>>> decode('36')
36
"""
j = Unpickler()
return j.restore(json.decode(string))
def decode(string):
"""Converts the JSON string into a Python object.
>>> str(decode('"my string"'))
'my string'
>>> decode('36')
36
"""
j = Unpickler()
return j.restore(json.decode(string))
def decode_complex_obj(self, pairs):
res_dict = {}
for k, v in pairs:
if "_date" in k or "_time" in k:
v = self.decode_date(v)
res_dict[k] = v
context = Unpickler()
res = context.restore(res_dict, reset=True)
return res
def BM_item_esquema(request):
if (request.method == 'PUT'):
u = Unpickler()
entidad = u.restore(request.json_body)
#id = request.params.matchdict['id']
esquemaItemDao = EsquemaItemDAO(request)
esquemaItem = esquemaItemDao.get_by_id(entidad["id"])
esquemaItem._esquema_id = entidad["_esquema_id"]
esquemaItem._item_id = entidad["_item_id"]
esquemaItemDao.update(esquemaItem)
return Response(json.dumps({'sucess': 'true'}))
elif (request.method == 'DELETE'):
u = Unpickler()
entidad = u.restore(request.json_body)
esquemaItemDao = EsquemaDAO(request)
esquemaItem = esquemaItemDao.get_by_id(entidad["id"])
esquemaItemDao.borrar(esquemaItem)
return Response(json.dumps({'sucess': 'true'}))
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 eliminar_tipofase(request):
"""
@summary: Maneja las solicitudes elimninar soporte de tipos de item de una fase.
@param request: Delete para eliminar.
@return: Retorna true en caso de exito.
"""
if (request.method == 'DELETE'):
u = Unpickler()
entidad = u.restore(request.json_body);
dao = TipoFaseDAO(request)
tipo_fase = dao.get_by_id(entidad["id"])
dao.borrar(tipo_fase)
return Response(json.dumps({'sucess': '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 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 delete_tipo(request):
u = Unpickler()
entidad = u.restore(request.json_body);
tipoItemDao = TipoItemDAO(request);
tipoItem = tipoItemDao.get_by_id(entidad["id"])
rd = TipoFaseDAO(request)
temp = rd.get_query().filter(TipoFase._tipo_id == entidad["id"]).first()
if temp == None:
tipoItemDao.borrar(tipoItem)
return Response(json.dumps({'sucess': 'true'}))
else:
return Response(json.dumps({'sucess': 'false' , "message": "El tipo de item se encuentra asociado a una fase" }))
def BM_esquemas(request):
if (request.method == 'PUT'):
u = Unpickler()
entidad = u.restore(request.json_body)
#id = request.params.matchdict['id']
esquemaDao = EsquemaDAO(request)
esquema = esquemaDao.get_by_id(entidad["id"])
esquema._nombre = entidad["_nombre"]
esquema._descripcion = entidad["_descripcion"]
esquema._etiqueta = entidad["_etiqueta"]
esquema._color = entidad["_color"]
esquema._fase_id = entidad["_fase_id"]
esquemaDao.update(esquema)
return Response(json.dumps({'sucess': 'true'}))
elif (request.method == 'DELETE'):
u = Unpickler()
entidad = u.restore(request.json_body)
esquemaDao = EsquemaDAO(request)
esquema = esquemaDao.get_by_id(entidad["id"])
esquemaDao.borrar(esquema)
return Response(json.dumps({'sucess': 'true'}))
def BM_atributo(request):
if (request.method == 'PUT'):
u = Unpickler()
entidad = u.restore(request.json_body);
#id = request.params.matchdict['id']
atributoTipoItemDAO = AtributoTipoItemDAO(request);
atributoItem = atributoTipoItemDAO.get_by_id(entidad["id"])
atributoItem._tipo = entidad["_tipo"]
atributoItem._valor = entidad["_valor"]
atributoItem._descripcion = entidad["_descripcion"]
atributoItem._opcional = entidad["_opcional"]
atributoItem._defecto = entidad["_defecto"]
atributoTipoItemDAO.update(atributoItem);
return Response(json.dumps({'sucess': 'true'}))
elif (request.method == 'DELETE'):
u = Unpickler()
entidad = u.restore(request.json_body);
atributoItemDao = AtributoTipoItemDAO(request);
atributo = atributoItemDao.get_by_id(entidad["id"])
atributoItemDao.borrar(atributo)
return Response(json.dumps({'sucess': 'true'}))
def importar(request):
u= Unpickler()
entidad = u.restore(request.json_body);
id_proyecto = entidad['id_proyecto']
proyectoDao = ProyectoDAO(request)
proyecto = proyectoDao.get_by_id(id_proyecto)
tipoItemDao = TipoItemDAO(request);
for id_tipo in entidad['_tipos']:
tipoItem = tipoItemDao.get_by_id(id_tipo)
nueva_entidad = TipoItem(tipoItem._nombre, tipoItem._comentario, tipoItem._color, tipoItem._prefijo,tipoItem._condicionado,proyecto)
tipoItemDao.crear(nueva_entidad)
a_ret = json.dumps({'sucess': 'true', 'tipos': entidad})
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 delete_proyectos(request):
"""
@summary: Maneja las solicitudes para eliminar proyectos.
@param request: Solicitud de eliminacion.
@return: Retorna true en caso de exito.
"""
u = Unpickler()
entidad = u.restore(request.json_body)
dao = ProyectoDAO(request)
proyecto = dao.get_by_id(entidad["id"])
fase_dao = FaseDAO(request)
fases = fase_dao.get_query().filter(
Fase._proyecto_id == proyecto._id).all()
for fase in fases:
fase_dao.borrar(fase)
dao.borrar(proyecto)
return Response(json.dumps({'sucess': 'true'}))
def 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 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 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 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 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 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)
