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 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 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 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 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 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 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 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 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 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 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}))
async def load(self, key: str) -> ():
self.client.create_container(self.container_name)
self.client.set_container_acl(
self.container_name, public_access=PublicAccess.Container
)
if not self.client.exists(container_name=self.container_name, blob_name=key):
return None, None
blob = self.client.get_blob_to_text(
container_name=self.container_name, blob_name=key
)
return Unpickler().restore(json.loads(blob.content)), blob.properties.etag
def __create_object(result) -> object:
"""Create an object from a result out of MongoDb.
:param result:
:return object:
"""
# get the document item from the result and turn into a dict
doc = result.get(MongodbStorage.DOCUMENT_TAG)
# create and return the object
result_obj = Unpickler().restore(doc)
return result_obj
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 __create_si(self, result) -> object:
"""Create an object from a result out of CosmosDB.
:param result:
:return object:
"""
# get the document item from the result and turn into a dict
doc = result.get("document")
# read the e_tag from Cosmos
if result.get("_etag"):
doc["e_tag"] = result["_etag"]
result_obj = Unpickler().restore(doc)
# create and return the object
return result_obj
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 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}))
async def __run_turn(dialog: Dialog, turn_context: TurnContext, state):
"""
Execute the turn of the bot. The functionality here closely resembles that which is found in the
Bot.on_turn method in an implementation that is using the regular BotFrameworkAdapter.
Also here in this example the focus is explicitly on Dialogs but the pattern could be adapted
to other conversation modeling abstractions.
"""
# If we have some state, deserialize it. (This mimics the shape produced by BotState.cs.)
dialog_state_property = (state[ComponentDialog.persisted_dialog_state]
if state else None)
dialog_state = (None if not dialog_state_property else
Unpickler().restore(json.loads(dialog_state_property)))
# A custom accessor is used to pass a handle on the state to the dialog system.
accessor = RefAccessor(dialog_state)
# Run the dialog.
await DialogHelper.run_dialog(dialog, turn_context, accessor)
# Serialize the result (available as Value on the accessor), and put its value back into a new json object.
return {
ComponentDialog.persisted_dialog_state:
None if not accessor.value else encode(accessor.value)
}
