def resolucion_rechazar_json(request):
if request.method != 'PUT':
return helpers.json_response({
'error': -1,
'msg': u'Método no soportado.'
})
request.PUT = QueryDict(request.body)
if 'resolucion_id_list' not in request.PUT:
return helpers.json_response({
'error': -2,
'msg': 'Debe indicar una lista de IDs.'
})
resolucion_id_list = json_loads(request.PUT['resolucion_id_list'])
if not isinstance(resolucion_id_list, list):
return helpers.json_response({
'error': -2,
'msg': 'Debe indicar una lista de IDs.'
})
models.Resolucion.objects.filter(pk__in=resolucion_id_list).update(
estatus=u'Rechazada',
observaciones=request.PUT.get('observaciones', ''))
return helpers.json_response({'error': 0, 'result': ''})
def ilicito_rest_delete(request):
request.DELETE = QueryDict(request.body)
if 'resolucion_id' not in request.DELETE:
return helpers.json_response({
'error':
-2,
'msg':
u'Debe indicar el ID de la resolución asociada.'
})
if 'ilicito_id_list' not in request.DELETE:
return helpers.json_response({
'error':
-2,
'msg':
u'Debe indicar los IDs de los ilícitos a borrar.'
})
ilicito_id_list = json_loads(request.DELETE['ilicito_id_list'])
if not (ilicito_id_list, list):
return helpers.json_response({
'error':
-2,
'msg':
u'Debe proporcionar una lista de ilícitos.'
})
models.Ilicito.objects.filter(
resolucion_id=request.DELETE['resolucion_id'],
pk__in=ilicito_id_list,
).delete()
return helpers.json_response({'error': 0, 'result': ''})
def ilicito_rest_get(request):
if 'resolucion_id' not in request.GET:
return helpers.json_response({
'error':
-2,
'msg':
u'Debe indicar el ID de la resolución asociada.'
})
result = list(
models.Ilicito.objects.filter(
resolucion_id=request.GET['resolucion_id']))
attachment = [
dict(
declaracion=unicode(row.declaracion) if row.declaracion else None,
sancion_codigo=row.sancion.codigo,
ut_max=row.sancion.ut_max,
ut_min=row.sancion.ut_min,
) for row in result
]
return helpers.json_response({
'error': 0,
'result': serialize('json', result),
'att': attachment
})
def resolucion_rest_get(request):
if 'resolucion_id' in request.GET:
query = {'pk': request.GET['resolucion_id']}
if not request.GET['resolucion_id'].isdigit():
return helpers.json_response({
'error':
-2,
'msg':
'Argumento mal formado para la ID.'
})
elif 'estatus' in request.GET:
query = {'estatus': request.GET['estatus']}
else:
return helpers.json_response({
'error': 0,
'result': [],
'attachment': []
})
resolucion_queryset = models.Resolucion.objects.filter(**query)
return helpers.json_response({
'error':
0,
'result':
serialize('json', resolucion_queryset),
'attachment': [
serialize('json', row.ilicito_set.filter())
for row in resolucion_queryset
]
})
def buscar_sancion_rest(request):
if request.method != 'GET':
return helpers.json_response({'error': -1, 'msg': 'Bad HTTP Method'})
if 'query' not in request.GET or not request.GET['query']:
return helpers.json_response({
'error':
-2,
'msg':
'Por favor, indique la sanción a buscar.'
})
if request.GET['query'].isdigit():
sanciones = models.Sancion.objects.filter(
codigo__contains=request.GET['query']).order_by('codigo')
else:
sanciones = models.Sancion.objects.filter(
descripcion__contains=request.GET['query'].upper()).order_by(
'codigo')
return helpers.json_response({
'error': 0,
'result': serialize('json', sanciones)
})
def cambio_de_perfil_rechazar_json(request):
if request.method != 'PUT':
return helpers.json_response({
'error': -1,
'msg': 'Method not allowed.'
})
request.PUT = QueryDict(request.body)
if 'solicitud_pk' not in request.PUT:
return helpers.json_response({
'error':
-2,
'msg':
'You should provide the <solicitud_pk> field'
})
if 'observaciones' not in request.PUT:
return helpers.json_response({
'error':
-2,
'msg':
'You should provide the <observaciones> field'
})
try:
solicitud = models.SolicitudCambioPerfil.objects.get(
pk=request.PUT['solicitud_pk'])
except models.SolicitudCambioPerfil.DoesNotExist:
return helpers.json_response({
'error':
-3,
'msg':
'There\'s not solicitud with the pk provided'
})
else:
solicitud.activo = False
solicitud.fecha_verificacion = datetime.now()
solicitud.observaciones = request.PUT['observaciones']
solicitud.save()
MailMan.cambio_de_perfil_rechazada(
data_dict={
'razon_social': solicitud.pst.razon_social,
'observaciones': solicitud.observaciones,
},
receptor_email=solicitud.pst.user.correo_electronico)
return helpers.json_response({'error': 0, 'result': ''})
def obtener_acta_reparo_json(request):
if request.method != 'GET':
return helpers.json_response({
'error': -1,
'msg': 'HTTP method not allow.'
})
if 'fiscalizacion_pk' not in request.GET:
return helpers.json_response({
'error':
-2,
'msg':
u'Debe indicar la pk de la fiscalización.'
})
fiscalizacion_queryset = models.Fiscalizacion.objects.filter(
pk=request.GET['fiscalizacion_pk'])
if fiscalizacion_queryset.count() == 0:
return helpers.json_response({
'error':
-3,
'msg':
u'No existe fiscalización alguna con el pk indicado.'
})
acta_queryset = acta_models.ActaDocumentos.objects.filter(
fiscalizacion=fiscalizacion_queryset.first(),
tipo__nombre=u'Acta de reparo',
)
if acta_queryset.count() == 0:
return helpers.json_response({
'error':
-3,
'msg':
u'No existe acta de reparo asociada a esta fiscalización.'
})
return helpers.json_response({
'error': 0,
'result': {
'acta_list':
serializers.serialize('json', acta_queryset),
'acta_atributo_list':
serializers.serialize(
'json',
acta_queryset.first().actareparoatributos_set.all()),
}
})
def guardar_acta_reparo_json(request):
if request.method != 'PUT':
return helpers.json_response({
'error': -1,
'msg': 'HTTP method not allow.'
})
request.PUT = helpers.nx_get_dict_array(QueryDict(request.body))
acta_queryset = acta_models.ActaDocumentos.objects.filter(
pk=request.PUT['acta']['pk']).update(**request.PUT['acta']['fields'])
for acta_atributo in request.PUT['acta']['atributo_list'].itervalues():
acta_models.ActaReparoAtributos.objects.filter(
pk=acta_atributo['pk']).update(**acta_atributo['fields'])
return helpers.json_response({'error': 0, 'result': u'[]'})
def ilicito_rest_put(request):
request.PUT = QueryDict(request.body)
if 'resolucion_id' not in request.PUT:
return helpers.json_response({
'error':
-2,
'msg':
u'Debe indicar el ID de la resolución asociada.'
})
if 'ilicito_obj_list' not in request.PUT:
return helpers.json_response({
'error':
-2,
'msg':
u'Debe indicar los ilícitos a modificar.'
})
ilicito_obj_list = json_loads(request.PUT['ilicito_obj_list'])
if not (ilicito_obj_list, list):
return helpers.json_response({
'error':
-2,
'msg':
u'Debe proporcionar una lista de ilícitos.'
})
try:
with transaction.atomic():
for ilicito in ilicito_obj_list:
models.Ilicito.objects.filter(
pk=ilicito['pk'],
resolucion_id=request.PUT['resolucion_id'],
).update(sancion_ut=ilicito['sancion_ut'])
except Exception:
return helpers.json_response({
'error':
-2,
'msg':
u'Por favor, verifique los cambios introducidos'
})
return helpers.json_response({'error': 0, 'result': ''})
def registrar_observaciones_json(request):
if request.method != 'PUT':
helpers.json_response({'error': -1, 'msg': 'HTTP method not allow.'})
request.PUT = QueryDict(request.body)
if 'acta_id' not in request.PUT:
return helpers.json_response({
'error':
-2,
'msg':
u'Debe indicar el ID de la verificación.'
})
if 'observaciones' not in request.PUT:
return helpers.json_response({
'error':
-2,
'msg':
u'Debe indicar las observaciones a registrar.'
})
if 'conclusiones' not in request.PUT:
return helpers.json_response({
'error':
-2,
'msg':
u'Debe indicar las conclusiones a registrar.'
})
try:
verificacion = verificacion_models.Verificacion.objects.get(
pk=request.PUT['acta_id'])
except verificacion_models.Verificacion.DoesNotExist:
return helpers.json_response({
'error':
-3,
'msg':
u'No existe verificación alguna con el ID indicado.'
})
else:
MailMan.verificacion_concluida(
data_dict={
'razon_social': verificacion.pst.razon_social,
'periodo_desde': verificacion.desde,
'periodo_hasta': verificacion.hasta,
'observaciones': request.PUT['observaciones'],
},
receptor_email=verificacion.pst.user.correo_electronico)
verificacion.conclusiones = request.PUT['conclusiones']
verificacion.observaciones = request.PUT['observaciones']
verificacion.save()
return helpers.json_response({'error': 0, 'result': u''})
def resolucion_rest(request):
if request.method == 'GET':
return resolucion_rest_get(request)
if request.method == 'POST':
return resolucion_rest_post(request)
if request.method == 'DELETE':
return resolucion_rest_delete(request)
return helpers.json_response({'error': -1, 'msg': u'Método no soportado.'})
def cambio_de_perfil_cancelar_json(request):
if request.method != 'POST':
return helpers.json_response({
'error': -1, 'msg': 'Method not allowed.'
})
solicitudes = models.SolicitudCambioPerfil.objects.filter(
pst=models.Pst.objects.get(user=request.user),
activo=True
)
if not solicitudes.count():
return helpers.json_response({
'error': -2,
'msg': '¡Actualmente no posee solicitudes pendientes por aprobar!'
})
solicitudes.update(activo=False)
return helpers.json_response({'error': 0, 'result': ''})
def resolucion_rest_delete(request):
request.DELETE = QueryDict(request.body)
if 'resolucion_id' not in request.DELETE:
return helpers.json_response({
'error':
-2,
'msg':
'Debe indicar el ID de la resolución a borrar.'
})
if not request.DELETE['resolucion_id'].isdigit():
return helpers.json_response({
'error':
-2,
'msg':
'Debe indicar el ID de la resolución a borrar.'
})
try:
resolucion = models.Resolucion.objects.get(
pk=request.DELETE['resolucion_id'])
except models.Resolucion.DoesNotExist:
return helpers.json_response({
'error':
-2,
'msg':
'No existe resolución con el ID proporcionado.'
})
else:
return helpers.json_response({
'error': 0,
'result': resolucion.delete()
})
return helpers.json_response({
'error': -2,
'msg': 'Algo ha ido muy mal en el servidor.'
})
def cambio_de_perfil_solicitar_json(request):
if request.method != 'POST':
return helpers.json_response({
'error': -1, 'msg': 'Method not allowed.'
})
solicitudes = models.SolicitudCambioPerfil.objects.filter(
pst=models.Pst.objects.get(user=request.user),
activo=True
)
if solicitudes.count():
return helpers.json_response({
'error': -2, 'msg': '¡Ya tiene una solicitud pendiente!'
})
models.SolicitudCambioPerfil(
pst=models.Pst.objects.get(user=request.user)
).save()
return helpers.json_response({'error': 0, 'result': ''})
def compromiso_pago_nuevo(request):
if 'conceptos' not in request.POST:
return json_response({
'error': -1,
'msg': 'Se requieren los conceptos.'
})
conceptos = json_loads(request.POST['conceptos'])
if not isinstance(conceptos, list) or not conceptos:
return json_response({
'error': -2,
'msg': 'Argumento invalido para los conceptos.'
})
conceptos = models.Concepto.objects.filter(
pst=Pst.objects.get(user=request.user), pago=None, id__in=conceptos)
if not conceptos:
return json_response({
'error':
-3,
'msg':
'No hay conceptos a los cuales asociar el nuevo pago.'
})
with transaction.atomic():
pago = models.Pago(pst=Pst.objects.get(user=request.user), total=0)
pago.save()
conceptos.update(pago=pago)
pago.total = sum(concepto.monto
for concepto in pago.concepto_set.all())
pago.save()
return json_response({
'error': 0,
'result': serializers.serialize('json', [pago])
})
def ilicito_rest_post(request):
request.POST = QueryDict(request.body)
if 'resolucion_id' not in request.POST:
return helpers.json_response({
'error':
-2,
'msg':
u'Debe indicar el ID de la resolución asociada.'
})
if 'ilicito_list' not in request.POST:
return helpers.json_response({
'error':
-2,
'msg':
u'Debe indicar los ilícitos a modificar.'
})
try:
resolucion = models.Resolucion.objects.get(
pk=request.POST['resolucion_id'])
except models.Resolucion.DoesNotExist:
return helpers.json_response({
'error':
-2,
'msg':
u'No existe resolución con el ID indicado.'
})
else:
try:
parse_ilicito_list(request, resolucion)
except AssertionError as e:
return helpers.json_response({'error': -2, 'msg': str(e)})
return helpers.json_response({'error': 0, 'result': ''})
def compromiso_pago_json(request):
if 'concepto_id' not in request.GET:
return json_response({'error': -1, 'msg': 'Se requiere el concepto.'})
try:
concepto = models.Concepto.objects.get(
pst=Pst.objects.get(user=request.user),
id=request.GET['concepto_id'])
except models.Concepto.DoesNotExist:
return json_response({'error': -2, 'msg': 'El concepto no existe'})
return json_response({
'error': 0,
'result': serializers.serialize('json', [concepto]),
'attached': {
'tipo': concepto.concepto_tipo.nombre,
'pago': None if concepto.pago is None else {
'id': concepto.pago.id,
'numero_documento': concepto.pago.numero_documento,
}
},
})
def resolucion_rest_post(request):
try:
resolucion_data = {
'funcionario':
request.user,
'pst':
reg_models.Pst.objects.get(rif=request.POST['pst_rif']),
'tipo_resolucion_id':
request.POST['tipo_resolucion_id'],
'verificacion_id':
request.POST['acta_id'],
'valor_ut':
cfg_models.UnidadTributaria.get_valor_para_fecha(
datetime.date.today())
}
factory_resolucion = FactoryCodigoActas(
Storage(es_una_resolucion=True,
objeto_verificacion=vrf_models.Verificacion.objects.get(
id=resolucion_data['verificacion_id'])))
resolucion_data['numero_documento'] = (
factory_resolucion.make_codigo())
with transaction.atomic():
nueva_resolucion = models.Resolucion(**resolucion_data)
nueva_resolucion.save()
parse_ilicito_list(request, nueva_resolucion)
return helpers.json_response({
'error':
0,
'result':
serialize('json', [nueva_resolucion])
})
except Exception as e:
return helpers.json_response({'error': -2, 'msg': str(e)})
def get_fecha_limite(request):
if 'periodo' not in request.GET:
return helpers.json_response({
'error': -1, 'msg': 'Debe proporcionar el periodo.'
})
try:
period = map(int, request.GET['periodo'].split('/'))
except ValueError:
return helpers.json_response({
'error': -2, 'msg': 'Bad value for the period.'
})
if not period or len(period) != 3 or period[0] != 1:
return helpers.json_response({
'error': -2, 'msg': 'Bad value for the period.'
})
result = models.CalendarioLaboral.get_n_siguiente_dia_laborable(
15, date(*reversed(period))
).strftime('%d/%m/%Y')
return helpers.json_response({'error': 0, 'result': result})
def solicitar_aprobacion_json(request):
if request.method != 'PUT':
return helpers.json_response({
'error': -1,
'msg': 'Method not allowed.'
})
request.PUT = QueryDict(request.body)
if 'acta_pk' not in request.PUT:
return helpers.json_response({
'error':
-2,
'msg':
'You should provide the <acta_pk> field'
})
acta_documento_queryset = models.ActaDocumentos.objects.filter(
pk=request.PUT['acta_pk'])
if acta_documento_queryset.count() == 0:
return helpers.json_response({
'error':
-2,
'msg':
'No existe acta alguna con la pk indicada.'
})
acta_documento_queryset.update(estatus=models.APROBACION_SOLICITADA)
return helpers.json_response({
'error':
0,
'result':
serializers.serialize('json', acta_documento_queryset)
})
def registrar_observaciones_json(request):
if request.method != 'PUT':
helpers.json_response({'error': -1, 'msg': 'HTTP method not allow.'})
request.PUT = QueryDict(request.body)
if 'acta_id' not in request.PUT:
return helpers.json_response({
'error':
-2,
'msg':
u'Debe indicar el ID de la fiscalización.'
})
if 'observaciones' not in request.PUT:
return helpers.json_response({
'error':
-2,
'msg':
u'Debe indicar las observaciones a registrar.'
})
if 'conclusiones' not in request.PUT:
return helpers.json_response({
'error':
-2,
'msg':
u'Debe indicar las conclusiones a registrar.'
})
try:
fiscalizacion = models.Fiscalizacion.objects.get(
pk=request.PUT['acta_id'])
except models.Fiscalizacion.DoesNotExist:
return helpers.json_response({
'error':
-3,
'msg':
u'No existe fiscalización alguna con el ID indicado.'
})
else:
fiscalizacion.conclusiones = request.PUT['conclusiones']
fiscalizacion.observaciones = request.PUT['observaciones']
fiscalizacion.save()
return helpers.json_response({'error': 0, 'result': u''})
def resolucion_solicitar_aprobacion_json(request):
if request.method != 'PUT':
return helpers.json_response({
'error': -1,
'msg': u'Método no soportado.'
})
request.PUT = QueryDict(request.body)
if 'resolucion_id' not in request.PUT:
return helpers.json_response({
'error':
-2,
'msg':
'Debe indicar el ID de la resolución a borrar.'
})
if not request.PUT['resolucion_id'].isdigit():
return helpers.json_response({
'error':
-2,
'msg':
'Debe indicar el ID de la resolución a borrar.'
})
try:
resolucion = models.Resolucion.objects.get(
pk=request.PUT['resolucion_id'])
except models.Resolucion.DoesNotExist:
return helpers.json_response({
'error':
-2,
'msg':
'No existe resolución con el ID proporcionado.'
})
else:
resolucion.estatus = u'Aprobación Solicitada'
resolucion.save()
return helpers.json_response({
'error': 0,
'result': serialize('json', [resolucion])
})
return helpers.json_response({
'error': -2,
'msg': 'Algo ha ido muy mal en el servidor.'
})
def concluir_verificacion_json(request):
if request.method != 'PUT':
helpers.json_response({'error': -1, 'msg': 'HTTP method not allow.'})
request.PUT = QueryDict(request.body)
if 'acta_id' not in request.PUT:
return helpers.json_response({
'error':
-2,
'msg':
u'Debe indicar el ID de la verificación a concluir.'
})
try:
verificacion = verificacion_models.Verificacion.objects.get(
pk=request.PUT['acta_id'])
except verificacion_models.Verificacion.DoesNotExist:
return helpers.json_response({
'error':
-3,
'msg':
u'No existe verificación alguna con el ID indicado.'
})
else:
if verificacion.estatus == verificacion_models.CONCLUIDA:
return helpers.json_response({
'error':
1,
'msg':
u'La verificación en cuestión ya está concluida.'
})
verificacion.estatus = verificacion_models.CONCLUIDA
verificacion.save()
return helpers.json_response({'error': 0, 'result': u''})
def declaraciones_rest(request):
if 'periodo' in request.GET:
try:
period = map(int, request.GET['periodo'].split('/'))
except ValueError:
return helpers.json_response({
'error': -2,
'msg': 'Bad value for the period.'
})
if not period or len(period) != 3:
return helpers.json_response({
'error': -2,
'msg': 'Bad value for the period.'
})
if 'pst' in request.GET:
result = Declaracion.objects.filter(
~Q(estatus=u'Anulada'),
pst=helpers.get_object_or_none(Pst, rif=request.GET['pst']),
periodo=date(*reversed(period))).order_by('fecha_presentacion')
if request.GET.get('detailed', False):
return helpers.json_response({
'error':
0,
'result':
serialize('json', result)
})
return helpers.json_response({
'error':
0,
'result':
json_dumps([{
'pk': row.pk,
'repr': unicode(row)
} for row in result])
})
result = Declaracion.objects.filter(
pst=helpers.get_object_or_none(Pst, user=request.user),
periodo=date(*reversed(period))).order_by('fecha_presentacion')
allow_definitiva = (result.count() == 0
or (result.last().tipo_declaracion.nombre
== (u'Declaración Definitiva')
and result.last().estatus == u'Anulada'))
if allow_definitiva:
return helpers.json_response({
'error':
0,
'result':
json_loads(serialize('json', []))
})
if result.last().estatus not in [u'Pagada', u'Anulada']:
return helpers.json_response({
'error':
-2,
'msg': ('La última declaración para el'
' periodo indicado no ha sido pagada.')
})
elif 'id' in request.GET:
result = Declaracion.objects.filter(pst=helpers.get_object_or_none(
Pst, user=request.user),
id=request.GET['id'])
else:
return helpers.json_response({
'error':
-1,
'msg':
'Debe indicar el periodo que va a declarar.'
})
return helpers.json_response({
'error':
0,
'result':
json_loads(serialize('json', result))
})
def resolucion_aprobar_json(request):
if request.method != 'PUT':
return helpers.json_response({
'error': -1,
'msg': u'Método no soportado.'
})
request.PUT = QueryDict(request.body)
if 'resolucion_id_list' not in request.PUT:
return helpers.json_response({
'error': -2,
'msg': 'Debe indicar una lista de IDs.'
})
resolucion_id_list = json_loads(request.PUT['resolucion_id_list'])
if not isinstance(resolucion_id_list, list):
return helpers.json_response({
'error': -2,
'msg': 'Debe indicar una lista de IDs.'
})
resolucion_queryset = models.Resolucion.objects.filter(
pk__in=resolucion_id_list)
with transaction.atomic():
resolucion_queryset.update(estatus=u'Aprobada')
for resolucion in resolucion_queryset:
concurrencia = models.Resolucion.calc_concurrencia(resolucion)
total_pagar = (sum(decimal
for decimal in concurrencia[1].itervalues()) +
concurrencia[0][1])
concepto_data = {
'pst':
resolucion.pst,
'concepto_tipo':
pagos_models.ConceptoTipo.objects.get(nombre=u'Multa'),
'monto':
total_pagar,
}
pagos_models.Concepto(**concepto_data).save()
intereses_moratorios = (
dcl_models.InteresMoratorio.get_intereses_moratorios(
resolucion.pst,
resolucion.verificacion.desde,
resolucion.verificacion.hasta,
))
for interes_moratorio in intereses_moratorios:
concepto_pago = pagos_models.Concepto(
pst=resolucion.pst,
concepto_tipo=pagos_models.ConceptoTipo.objects.get(
nombre=(u'Intereses moratorios por pago extemporáneo'
u' (Art. 66 del COT)')),
monto=interes_moratorio.monto_interes,
)
concepto_pago.save()
interes_moratorio.concepto_pago = concepto_pago
interes_moratorio.save()
return helpers.json_response({'error': 0, 'result': ''})
def guardar_nueva_acta_reparo_json(request):
if request.method != 'POST':
return helpers.json_response({
'error': -1,
'msg': 'HTTP method not allow.'
})
if 'acta_fecha_notificacion' not in request.POST:
return helpers.json_response({
'error':
-2,
'msg':
u'Debe indicar la fecha de notificación.'
})
fecha_notificacion = datetime(
*map(int, request.POST['acta_fecha_notificacion'].split('-')))
acta_atributo_dict = helpers.get_dict_array(request.POST, 'acta_atributos',
[])
if 'fiscalizacion_pk' not in request.POST:
return helpers.json_response({
'error':
-2,
'msg':
u'Debe indicar la pk de la fiscalización.'
})
fiscalizacion_queryset = models.Fiscalizacion.objects.filter(
pk=request.POST['fiscalizacion_pk'])
if fiscalizacion_queryset.count() == 0:
return helpers.json_response({
'error':
-3,
'msg':
u'No existe fiscalización alguna con el pk indicado.'
})
factory_data = Storage(
objeto=fiscalizacion_queryset.first(),
objeto_tipo_acta=acta_models.TipoActa.objects.get(
nombre=u'Acta de reparo'),
tipo_procedimiento=factory.FactoryCodigoActas.TIPO_FISCALIZACION,
)
factory_obj = factory.FactoryCodigoActas(factory_data)
acta = acta_models.ActaDocumentos(
codigo=factory_obj.make_codigo(),
estatus=acta_models.NO_NOTIFICADA,
fecha_notificacion=fecha_notificacion,
fiscalizacion=factory_data.objeto,
tipo=factory_data.objeto_tipo_acta,
)
with transaction.atomic():
acta.save()
for atributo in acta_atributo_dict.itervalues():
del atributo['$$hashKey']
atributo['periodo'] = datetime(
*map(int, atributo['periodo'].split('-')))
if not atributo.pop('readonly') == 'true':
acta_models.ActaReparoAtributos(acta=acta, **atributo).save()
return helpers.json_response({'error': 0, 'result': []})
