def post(self, request):
cidades = Cidade.objects.filter(uf_id=int(request.POST['uf_id']))
json_cidades = []
for uf in cidades:
serializer = CidadeSerializer(uf)
json_cidades.append(serializer.data)
return JSONResponse(json_cidades)
def post(self, request):
page = None
if 'page' in request.POST:
page = request.POST['page']
if 'data' in request.POST:
tipos_infracao = TipoInfracao.objects.get_tipos_infracao_sicronismo(
page, request.POST['data'])
else:
tipos_infracao = TipoInfracao.objects.get_tipos_infracao_sicronismo(
page)
tipos_infracao_js = []
for tipo_infracao in tipos_infracao:
serializer = TipoInfracaoSerializer(tipo_infracao)
tipos_infracao_js.append(serializer.data)
page = {
'num_pages': tipos_infracao.paginator.num_pages,
'number': tipos_infracao.number,
'tipos_infracao': tipos_infracao_js
}
return JSONResponse(page)
def post(self, request):
"""Devolve para a carga inicial as cidades"""
cidades = Cidade.objects.filter(uf_id=int(request.POST['uf_id']))
json_cidades = []
for estado in cidades:
serializer = CidadeSerializer(estado)
json_cidades.append(serializer.data)
return JSONResponse(json_cidades)
def post(self, request):
if 'data' in request.POST:
config_sinc = ConfigSinc.objects.get_config_sinc_sicronismo(
request.POST['data'])
else:
config_sinc = ConfigSinc.objects.get_config_sinc_sicronismo()
serializer = ConfigSincSerializer(config_sinc)
return JSONResponse(serializer.data)
def post(self, request):
if 'data' in request.POST:
agentes = Agente.objects.get_agentes_sicronismo(request.POST['data'])
else:
agentes = Agente.objects.get_agentes_sicronismo()
agentes_js = []
for agente in agentes:
serializer = AgenteSerializer(agente)
agentes_js.append(serializer.data)
return JSONResponse(agentes_js)
def post(self, request):
if 'data' in request.POST:
especies = Especie.objects.get_especies_sicronismo(request.POST['data'])
else:
especies = Especie.objects.get_especies_sicronismo()
especies_js = []
for especie in especies:
serializer = EspecieSerializer(especie)
especies_js.append(serializer.data)
return JSONResponse(especies_js)
def post(self, request):
if 'data' in request.POST:
tipos = TipoVeiculo.objects.get_tipos_veiculo_sicronismo(
request.POST['data'])
else:
tipos = TipoVeiculo.objects.get_tipos_veiculo_sicronismo()
tipos_js = []
for veiculo in tipos:
serializer = TipoVeiculoSerializer(veiculo)
tipos_js.append(serializer.data)
return JSONResponse(tipos_js)
def post(self, request):
"""Pega as configurações e envia para o servidor"""
if 'data' in request.POST:
config_sinc = ConfigSinc.objects.get_config_sinc_sicronismo(
request.POST['data'])
else:
config_sinc = ConfigSinc.objects.get_config_sinc_sicronismo()
serializer = ConfigSincSerializer(config_sinc)
return JSONResponse(serializer.data)
def post(self, request):
if 'data' in request.POST:
cores = Cor.objects.get_cores_sicronismo(request.POST['data'])
else:
cores = Cor.objects.get_cores_sicronismo()
cores_js = []
for cor in cores:
serializer = CorSerializer(cor)
cores_js.append(serializer.data)
return JSONResponse(cores_js)
def post(self, request):
if 'data' in request.POST:
ufs = UF.objects.get_ufs_sicronismo(request.POST['data'])
else:
ufs = UF.objects.get_ufs_sicronismo()
json_ufs = []
for uf in ufs:
serializer = UFSerializer(uf)
json_ufs.append(serializer.data)
return JSONResponse(json_ufs)
def post(self, request):
"""Retorna as categorias nas infrações"""
if 'data' in request.POST:
categorias = Categoria.objects.get_categorias_sicronismo(
request.POST['data'])
else:
categorias = Categoria.objects.get_categorias_sicronismo()
cores_js = []
for categoria in categorias:
serializer = CategoriaSerializer(categoria)
cores_js.append(serializer.data)
return JSONResponse(cores_js)
def _view(request, *args, **kwargs):
print request.POST
if 'imei' in request.POST:
print request.POST['imei']
dispositivo = Dispositivo.objects.existe_dispositivo(
request.POST['imei'])
if dispositivo:
return view_func(request, *args, **kwargs)
return JSONResponse({'status': 'Dispositivo nao encontrado!'},
status=status.HTTP_404_NOT_FOUND)
def post(self, request):
if 'data' in request.POST:
regioes = Regiao.objects.get_regioes_sicronismo(
request.POST['data'])
else:
regioes = Regiao.objects.get_regioes_sicronismo()
regios_js = []
for regiao in regioes:
serializer = RegiaoSerializer(regiao)
regios_js.append(serializer.data)
print('regios_js : ', regios_js)
return JSONResponse(regios_js)
def post(self, request):
if 'data' in request.POST:
cidades = Cidade.objects.get_cidades_sicronismo(
int(request.POST['uf_id']), request.POST['data'])
else:
cidades = Cidade.objects.get_cidades_sicronismo(
int(request.POST['uf_id']))
json_cidades = []
for uf in cidades:
serializer = CidadeSerializer(uf)
json_cidades.append(serializer.data)
return JSONResponse(json_cidades)
def post(self, request):
"""Envia as Ufs para o Android"""
if 'data' in request.POST:
ufs = UF.objects.get_ufs_sicronismo(request.POST['data'])
else:
ufs = UF.objects.get_ufs_sicronismo()
json_ufs = []
for estado in ufs:
serializer = UFSerializer(estado)
json_ufs.append(serializer.data)
return JSONResponse(json_ufs)
def post(self, request):
status = True
if int(request.POST['status']) == 0:
status = False
dispositivo = Dispositivo.objects.get(imei=str(request.POST['imei']))
agente = int(request.POST['agente'])
# Login
if status == True:
agente_login = Agente_login.objects.filter(device=dispositivo.id, agente_id=agente, status=True)
if agente_login:
# return False
return JSONResponse({'permission': 0})
else:
agente_login = Agente_login()
agente_login.agente_id = agente
agente_login.device_id = dispositivo.id
agente_login.status = True
agente_login.save()
# return True
return JSONResponse({'permission': 1})
# Logout
else:
agente_login = Agente_login.objects.get(device=dispositivo.id, agente_id=agente, status=True)
if agente_login:
agente_login.status = False
agente_login.data_logout = timezone.now()
agente_login.save()
# return True
return JSONResponse({'permission': 1})
else:
# return False
return JSONResponse({'permission': 0})
def post(self, request):
"""Retorna para o Android as regiões no servidor"""
if 'data' in request.POST:
regioes = Regiao.objects.get_regioes_sicronismo(
request.POST['data'])
else:
regioes = Regiao.objects.get_regioes_sicronismo()
regios_js = []
for regiao in regioes:
serializer = RegiaoSerializer(regiao)
regios_js.append(serializer.data)
return JSONResponse(regios_js)
def post(self, request):
if 'data' in request.POST:
categorias = Categoria.objects.get_categorias_sicronismo(
request.POST['data'])
else:
categorias = Categoria.objects.get_categorias_sicronismo()
cores_js = []
for categoria in categorias:
serializer = CategoriaSerializer(categoria)
cores_js.append(serializer.data)
print serializer.data
return JSONResponse(cores_js)
def post(self, request):
"""Pega as configurações e envia para o servidor"""
if 'data' in request.POST:
dados_sqlite = Detrans_sqlite.objects.get_dados_sqlite_sicronismo(
request.POST['data'])
else:
dados_sqlite = Detrans_sqlite.objects.get_dados_sqlite_sicronismo()
dados_js = []
for dados in dados_sqlite:
serializer = DadosSqliteSerializer(dados)
dados_js.append(serializer.data)
print dados_js
return JSONResponse(dados_js)
def post(self, request):
"""Envia a páginação das cidades para o Android"""
if 'data' in request.POST:
cidades = Cidade.objects.get_cidades_sicronismo(
int(request.POST['uf_id']), request.POST['data'])
else:
cidades = Cidade.objects.get_cidades_sicronismo(
int(request.POST['uf_id']))
json_cidades = []
for estado in cidades:
serializer = CidadeSerializer(estado)
json_cidades.append(serializer.data)
return JSONResponse(json_cidades)
def post(self, request):
ids_json = loads(request.POST['id_infringement'])
img_json = "" + str(request.POST['imagem'])
img_json = img_json.split(",")
status_core = []
count = 0
for ids in ids_json:
Img = Image()
Img.infracao_id = ids['infringement_id']
arqv = open('imagens_analise.txt', 'r')
texto = arqv.readlines()
texto.append(img_json[count])
texto.append('\n \n \n \n \n \n \n')
arqv = open('imagens_analise.txt', 'w')
arqv.writelines(texto)
arqv.close()
imgdata = base64.b64decode(img_json[count])
filename = 'media/infracao_images/inf' + str(count) + str(
Img.infracao_id) + '.png'
with open(filename, 'wb') as f:
f.write(imgdata)
Img.photo = filename
Img.save()
status = {'isStatus': 1}
status_core.append(status)
count += 1
print "CONTADOR TOTAL", count
status_core = dumps(status_core, ensure_ascii=False)
print status_core
return JSONResponse(status_core)
def post(self, request):
page = None
if 'page' in request.POST:
page = request.POST['page']
if 'data' in request.POST:
veiculos = Veiculo.objects.get_veiculos_sicronismo(page, request.POST['data'])
else:
veiculos = Veiculo.objects.get_veiculos_sicronismo(page)
veiculos_js = []
print 'total veiculos : ', len(veiculos)
for veiculo in veiculos:
serializer = VeiculoSerializer(veiculo)
veiculos_js.append(serializer.data)
page = {'num_pages': veiculos.paginator.num_pages, 'number': veiculos.number, 'veiculos': veiculos_js}
return JSONResponse(page)
def _view(request, *args, **kwargs):
if 'imei' in request.POST:
dispositivo = Dispositivo.objects.existe_dispositivo(
request.POST['imei'])
if dispositivo:
return view_func(request, *args, **kwargs)
else:
acesso = Acesso.objects.get_or_create(
imei=request.POST['imei'])[0]
try:
acesso.usuario = Agente.objects.get(
id=request.POST['agente']).username
except:
acesso.usuario = Agente.objects.get(
username=request.POST['username']).username
acesso.dt_acesso = datetime.datetime.now()
acesso.save()
return JSONResponse({'status': 'Dispositivo nao encontrado!'},
status=status.HTTP_403_FORBIDDEN)
def post(self, request):
page = None
if 'page' in request.POST:
page = request.POST['page']
if 'data' in request.POST:
modelos = Modelo.objects.get_modelos_sicronismo(
page, request.POST['data'])
else:
modelos = Modelo.objects.get_modelos_sicronismo(page)
modelos_js = []
for modelo in modelos:
serializer = ModeloSerializer(modelo)
modelos_js.append(serializer.data)
page = {
'num_pages': modelos.paginator.num_pages,
'number': modelos.number,
'modelos': modelos_js
}
return JSONResponse(page)
def post(self, request):
if not Bloco.objects.filter(usuario=request.user) or \
Bloco.objects.filter(usuario=request.user, ativo=True):
bloco = AddBloco(request)
# caso não houver bloco padrão cadastrado
if not bloco:
return JSONResponse(
{'error': 'Não há bloco mestre cadastrado'})
bloco.save()
serializer = BlocoSerializer(bloco)
js_core = []
js_core.append(serializer.data)
return JSONResponse(js_core)
else:
bp = BlocoPadrao.objects.get(ativo=True)
bloco = Bloco.objects.filter(usuario=request.user,
ativo=True).order_by('-data')[0]
inf = Infracao.objects.filter(id__range=[
bloco.fim_intervalo -
(bp.numero_paginas - 1), bloco.fim_intervalo
])
# Se excedeu o número de páginas necessárias para a reposição
if (bp.numero_paginas - len(inf)) <= bloco.minimo_pag_restantes:
core_js = []
bloco_antigo = Bloco.objects.filter(
usuario=request.user).order_by('-data_alterado')[0]
bloco_antigo.ativo = False
if (bp.numero_paginas - len(inf)) > 0:
bloco_antigo.inicio_intervalo = (inf[len(inf) - 1].id) + 1
bloco_antigo.minimo_pag_restantes = 0
seria = BlocoSerializer(bloco_antigo)
core_js.append(seria.data)
bloco_antigo.save()
bloco_novo = AddBloco(request)
bloco_novo.save()
serializer = BlocoSerializer(bloco_novo)
core_js.append(serializer.data)
return JSONResponse(core_js)
else:
bloco = Bloco.objects.filter(
usuario=request.user).order_by('-data')
core_js = []
bp = BlocoPadrao.objects.get(ativo=True)
if len(bloco) > 1:
inf1 = Infracao.objects.filter(id__range=[
bloco[1].fim_intervalo -
(bp.numero_paginas - 1), bloco[1].fim_intervalo
])
if bp.minimo_pag_restantes >= (bp.numero_paginas -
len(inf1)) > 0:
bloco1 = Bloco.objects.get(id=bloco[1].id)
bloco1.inicio_intervalo = (inf1[len(inf1) - 1].id) + 1
bloco1.minimo_pag_restantes = 0
bloco1.status = False
bloco1.data_alterado = timezone.now()
bloco1.save()
serializer = BlocoSerializer(bloco1)
core_js.append(serializer.data)
pos = len(inf)
bloco = Bloco.objects.get(id=bloco[0].id)
bloco.data_alterado = timezone.now()
if pos > 0:
bloco.inicio_intervalo = inf[pos - 1].id + 1
bloco.save()
serializer = BlocoSerializer(bloco)
core_js.append(serializer.data)
return JSONResponse(core_js)
def post(self):
det = Configuracao_DET.objects.filter()
autuador = str(det[0].autuador)
return JSONResponse({'autuador': autuador})
def post(self, request):
if not Bloco.objects.filter(usuario=request.user):
bloco = AddBloco(request)
bloco.save()
bp = BlocoPadrao.objects.get(ativo=True)
bp.contador += bp.numero_paginas
bp.save()
serializer = BlocoSerializer(bloco)
print serializer.data
js_core = []
js_core.append(serializer.data)
return JSONResponse(js_core)
else:
bloco = Bloco.objects.filter(
usuario=request.user).order_by('-data')[0]
inf = Infracao.objects.filter(
id__range=[bloco.inicio_intervalo, bloco.fim_intervalo])
# Datetime Login User
usr = Agente_login.objects.get(agente_id=request.user.id,
status=True)
if (timezone.now() - usr.data_login).total_seconds() / 60 < 7:
bloco = Bloco.objects.filter(
usuario=request.user).order_by('-data_alterado')
core_js = []
if len(bloco) > 1:
inf1 = Infracao.objects.filter(id__range=[
bloco[1].inicio_intervalo, bloco[1].fim_intervalo
])
if (bloco[1].fim_intervalo -
len(inf1)) <= bloco[1].minimo_pag_restantes:
bloco = Bloco.objects.get(id=bloco[1].id)
bloco.inicio_intervalo += len(inf1)
bloco.data_alterado = timezone.now()
bloco.save()
serializer = BlocoSerializer(bloco)
core_js.append(serializer.data)
pos = len(inf) - 1
bloco = Bloco.objects.get(id=bloco[0].id)
bloco.data_alterado = timezone.now()
if pos > 0:
bloco.inicio_intervalo = (inf[pos].id) + 1
bloco.save()
serializer = BlocoSerializer(bloco)
core_js.append(serializer.data)
return JSONResponse(core_js)
else:
if (bloco.fim_intervalo -
len(inf)) <= bloco.minimo_pag_restantes:
bloco = Bloco.objects.filter(
usuario=request.user).order_by('-data_alterado')[0]
bloco.ativo = False
bloco.save()
bloco = AddBloco(request)
bloco.save()
bp = BlocoPadrao.objects.get(ativo=True)
bp.contador += bp.numero_paginas
bp.save()
serializer = BlocoSerializer(bloco)
core_js = []
core_js.append(serializer.data)
return JSONResponse(core_js)
def post(self, request):
return JSONResponse({'data': datetime.datetime.now().strftime("%d/%m/%Y %H:%M:%S")})
def post(self, request):
"""envia para o servidor a data de agora"""
return JSONResponse(
{'data': datetime.datetime.now().strftime("%d/%m/%Y %H:%M:%S")})