class StatusView(View):
template = 'detrans_sqlite/status_sqlite.html'
@method_decorator(permissao_geral_required())
def get(self, request):
global myProcess
status = myProcess.get_status_str()
erro = myProcess.is_erro_processo
status_mensagem = myProcess.get_status_mensagem_str()
if "refresh" in request.GET:
import json
list = json.dumps([status, erro, status_mensagem])
return HttpResponse(list)
return render(request, self.template, {
'status': status,
'erro': erro,
'status_mensagem': status_mensagem
})
@method_decorator(permissao_geral_required())
def post(self, request):
global myProcess
myProcess.stop()
return redirect('cria-sqlite-cancelado')
class CadastroTipoView(View):
template = 'tipo_veiculo/salvar.html'
@method_decorator(permissao_geral_required())
def get(self, request, tipo_id=None):
if tipo_id:
tipo = TipoVeiculo.objects.get(pk=tipo_id)
form = FormTipoVeiculo(instance=tipo)
else:
form = FormTipoVeiculo()
return render(request, self.template, {'form': form})
@method_decorator(permissao_geral_required())
def post(self, request, tipo_id=None):
if tipo_id:
tipo = TipoVeiculo.objects.get(pk=tipo_id)
form = FormTipoVeiculo(instance=tipo, data=request.POST)
mensagem = 'Tipo veiculo editado com sucesso!'
else:
form = FormTipoVeiculo(request.POST)
mensagem = 'Tipo veiculo inserido com sucesso!'
if form.is_valid():
form.save()
messages.success(request, mensagem)
return redirect('/tipo-veiculo/consulta/')
return render(request, self.template, {'form': form})
class ImportaModelo(View):
template_name = 'modelo/importa.html'
@method_decorator(permissao_geral_required())
def get(self, request):
form = FormArquivo()
return render(request, self.template_name, {'form': form})
@method_decorator(permissao_geral_required())
def post(self, request):
i = 0
if 'arquivo' in request.FILES and str(
request.FILES['arquivo'])[-4:] == ".txt":
arq = request.FILES['arquivo']
for linha in arq:
try:
linha = linha.encode('UTF-8')
cod = linha[0:6]
desc = linha[6:].strip()
novo_modelo = Modelo(codigo=cod, descricao=desc)
novo_modelo.save()
i += 1
except:
continue
else:
form = FormArquivo()
return render(request, self.template_name, {
'form': form,
'erro': 'erro'
})
return render(request, self.template_name, {'qtd': i, 'envio': True})
class CadastroVeiculoView(View):
template = 'veiculo/salvar.html'
@method_decorator(permissao_geral_required())
def get(self, request, veiculo_id=None):
if veiculo_id:
veiculo = Veiculo.objects.get(renavam=veiculo_id)
form = FormVeiculo(veiculo.cidade.uf_id, instance=veiculo)
form.fields['uf'].initial = veiculo.cidade.uf_id
else:
form = FormVeiculo(None)
return render(request, self.template, {'form': form})
@method_decorator(permissao_geral_required())
def post(self, request, veiculo_id=None):
if veiculo_id:
veiculo = Veiculo.objects.get(renavam=veiculo_id)
form = FormEditarVeiculo(request.POST['uf'],
data=request.POST,
instance=veiculo)
mensagem = 'Veiculo editado com sucesso!'
else:
form = FormVeiculo(request.POST['uf'], request.POST)
mensagem = 'Veiculo inserido com sucesso!'
if form.is_valid():
form.save()
messages.success(request, mensagem)
return redirect('/veiculo/consulta/')
return render(request, self.template, {'form': form})
class CadastroLeisView(View):
template = 'leis/salvar.html'
@method_decorator(permissao_geral_required())
def get(self, request, condutor_id=None):
if condutor_id:
leis = Lei.objects.get(pk=condutor_id)
form = FormLei(instance=leis)
else:
form = FormLei()
return render(request, self.template, {'form': form})
@method_decorator(permissao_geral_required())
def post(self, request, condutor_id=None):
if condutor_id:
leis = Lei.objects.get(pk=condutor_id)
form = FormLei(instance=leis, data=request.POST)
mensagem = 'Lei editada com sucesso!'
else:
form = FormLei(request.POST)
mensagem = 'Lei inserida com sucesso!'
if form.is_valid():
form.save()
messages.success(request, mensagem)
return redirect('/legislacao/consulta/')
return render(request, self.template, {'form': form})
class CadastroBlocoView(View):
template = 'bloco/salvar.html'
@method_decorator(permissao_geral_required())
def get(self, request, bloco_id=None):
if bloco_id:
bloco = BlocoPadrao.objects.get(pk=bloco_id)
form = FormBloco(instance=bloco)
else:
form = FormBloco()
return render(request, self.template, {'form': form})
@method_decorator(permissao_geral_required())
def post(self, request, bloco_id=None):
bloco_id = bloco_id
form = FormBloco(request.POST)
is_input = True
if bloco_id:
bloco_padrao = BlocoPadrao.objects.get(pk=bloco_id)
form = FormBloco(instance=bloco_padrao, data=request.POST)
is_input = False
mensagem = 'Bloco editado com sucesso!'
else:
form = FormBloco(request.POST)
mensagem = 'Bloco criado com sucesso!'
if form.is_valid():
if int(request.POST['inicio_intervalo']) < 0 or \
int(request.POST['inicio_intervalo']) > \
int(request.POST['fim_intervalo']):
return redirect('/bloco/')
if is_input:
post = form.save(commit=False)
# Controle de bloco campo 'ativo'
bloco = BlocoPadrao.objects.filter(ativo=True)
if len(bloco) >= 1:
post.ativo = False
form.save()
else:
form.save()
else:
form.save()
messages.success(request, mensagem)
return redirect('/bloco/consulta/')
return render(request, self.template, {'form': form})
class ImportaCor(View):
"""Importa as cores"""
template_name = 'cor/importa.html'
@method_decorator(permissao_geral_required())
def get(self, request):
"""Faz um formulário e envia para o template"""
form = FormArquivo()
return render(request, self.template_name, {'form': form})
@method_decorator(permissao_geral_required())
def post(self, request):
"""Envia o arquivo de cores para a base de dados"""
i = 0
if 'arquivo' in request.FILES and str(
request.FILES['arquivo'])[-4:] == ".txt":
arq = request.FILES['arquivo']
for linha in arq:
try:
linha = linha.encode('UTF-8')
cod = linha[0:2]
cor = linha[2:].strip()
nova_cor = Cor.objects.filter(codigo=cod).first()
if nova_cor:
nova_cor.descricao = cor
else:
nova_cor = Cor(codigo=cod, descricao=cor)
nova_cor.save()
i += 1
except Exception:
pass
return render(request, self.template_name, {
'qtd': i,
'envio': True
})
else:
form = FormArquivo()
return render(request, self.template_name, {
'form': form,
'erro': 'arquivo inválido'
})
class CriaSqliteCanceladoView(View):
template = 'detrans_sqlite/cria_sqlite_cancelado.html'
@method_decorator(permissao_geral_required())
def get(self, request):
return render(request, self.template)
@method_decorator(permissao_geral_required())
def post(self, request):
global myProcess
myProcess = ThreadDetransSqlite('importa')
myProcess.start()
return redirect('status-sqlite')
class CriaSqliteView(View):
template = 'detrans_sqlite/cria_sqlite.html'
@method_decorator(permissao_geral_required())
def get(self, request):
detrans_sqlite = Detrans_sqlite.objects.filter(is_finished=True).last()
return render(request, self.template, {'sqlite': detrans_sqlite})
@method_decorator(permissao_geral_required())
def post(self, request):
global myProcess
myProcess = ThreadDetransSqlite('importa')
myProcess.start()
return redirect('status-sqlite')
class CarregaTiposInfracao(View):
template = 'tipo_veiculo/carregatipos.html'
@method_decorator(permissao_geral_required())
def get(self, request):
module_dir = os.path.dirname(__file__) # get current directory
path = os.path.join(module_dir, 'tipos2.csv')
abrir = open(path, 'r')
for line in abrir:
l = line.split(',')
ls = Lei.objects.filter(lei=l[1])
if ls:
lei = ls[0]
else:
lei = Lei(lei=l[1])
lei.save()
t = TipoInfracao(codigo=l[0].strip(),
descricao=l[2].strip(),
lei=lei)
t.save()
abrir.close()
tipos = TipoInfracao.objects.all()
return render(request, self.template, {'tipos': tipos})
class ImportaVeiculo(View):
template_name = 'veiculo/importa.html'
@method_decorator(permissao_geral_required())
def get(self, request):
form = FormArquivo()
return render(request, self.template_name, {'form': form})
@method_decorator(permissao_geral_required())
def post(self, request):
i = 0
linhas_erro_encoding = []
if 'arquivo' in request.FILES and str(
request.FILES['arquivo'])[-4:] == ".txt":
arq = request.FILES['arquivo']
for linha in arq:
if linha.strip() == '':
continue
encoding = chardet.detect(linha)
try:
linha = linha.encode('utf-8')
except Exception:
linhas_erro_encoding.append((
linha,
encoding['encoding'],
))
continue
Veiculo.objects.importa_renavam(linha)
i += 1
return render(request, self.template_name, {
'qtd': i,
'envio': True
})
else:
form = FormArquivo()
return render(request, self.template_name, {
'form': form,
'erro': 'erro'
})
class ImportaCategoria(View):
"""Importa as categorias"""
template_name = 'categoria/importa.html'
@method_decorator(permissao_geral_required())
def get(self, request):
"""Cria um formulário de categorias"""
form = FormArquivo()
return render(request, self.template_name, {'form': form})
@method_decorator(permissao_geral_required())
def post(self, request):
"""Manda os arquivos importados para o servidor"""
i = 0
if 'arquivo' in request.FILES and str(
request.FILES['arquivo'])[-4:] == ".txt":
arq = request.FILES['arquivo']
for linha in arq:
try:
linha = linha.encode('UTF-8')
cod = linha[0:2]
desc = linha[2:].strip()
nova_categoria = Categoria(codigo=cod, descricao=desc)
nova_categoria.save()
i += 1
except Exception:
pass
return render(request, self.template_name, {
'qtd': i,
'envio': True
})
else:
form = FormArquivo()
return render(request, self.template_name, {
'form': form,
'erro': 'erro'
})
class RemoveDispositivoAcessoView(View):
"""Remove os dispositivos"""
template_name = 'dispositivo/acesso.html'
@method_decorator(permissao_geral_required())
def get(self, request, dispositivo_id=None):
"""Remove o acesso"""
Acesso.objects.get(pk=dispositivo_id).delete()
return redirect('/dispositivo/acesso/')
class CadastroDETView(View):
template = 'det/salvar.html'
@method_decorator(permissao_geral_required())
def get(self, request, det_id=None):
det = Configuracao_DET.objects.filter()
if len(det) > 0:
det_id = det[0].id
if det_id:
det = Configuracao_DET.objects.get(pk=det_id)
form = FormDet(instance=det)
else:
form = FormDet()
return render(request, self.template, {'form': form})
@method_decorator(permissao_geral_required())
def post(self, request, det_id=None):
det = Configuracao_DET.objects.filter()
if len(det) > 0:
det_id = det[0].id
if det_id:
cor = Configuracao_DET.objects.get(pk=det_id)
form = FormDet(instance=cor, data=request.POST)
else:
form = FormDet(request.POST)
if form.is_valid():
form.save(request)
return redirect('/')
else:
return redirect('/config/set/det')
class ImportaTipoVeiculo(View):
template_name = 'tipo_veiculo/importa.html'
@method_decorator(permissao_geral_required())
def get(self, request):
form = FormArquivo()
return render(request, self.template_name, {'form': form})
@method_decorator(permissao_geral_required())
def post(self, request):
i = 0
if 'arquivo' in request.FILES and str(
request.FILES['arquivo'])[-4:] == ".txt":
arq = request.FILES['arquivo']
for linha in arq:
try:
linha = linha.encode('UTF-8')
cod = linha[0:2]
desc = linha[2:].strip()
nova_categoria = TipoVeiculo(codigo=cod, descricao=desc)
nova_categoria.save()
i += 1
except Exception:
pass
return render(request, self.template_name, {
'qtd': i,
'envio': True
})
else:
form = FormArquivo()
return render(request, self.template_name, {
'form': form,
'erro': 'erro'
})
class CadastroEspecieView(View):
"""View para cadastrar especies de carros"""
template = 'especie/salvar.html'
@method_decorator(permissao_geral_required())
def get(self, request, especie_id=None):
"""Envia o formulário para o template"""
if especie_id:
especie = Especie.objects.get(pk=especie_id)
form = FormEspecie(instance=especie)
else:
form = FormEspecie()
return render(request, self.template, {'form': form})
@method_decorator(permissao_geral_required())
def post(self, request, especie_id=None):
"""Envia os dados do template para o banco de dados"""
if especie_id:
especie = Especie.objects.get(pk=especie_id)
form = FormEspecie(instance=especie, data=request.POST)
mensagem = 'Espécie editada com sucesso!'
else:
form = FormEspecie(request.POST)
mensagem = 'Espécie inserida com sucesso!'
if form.is_valid():
form.save()
messages.success(request, mensagem)
return redirect('/especie/consulta/')
return render(request, self.template, {'form': form})
class CadastroCategoriaView(View):
"""Cadastra as categorias"""
template = 'categoria/salvar.html'
@method_decorator(permissao_geral_required())
def get(self, request, categoria_id=None):
"""Pega o formulário para cadastrar e atualizar uma categoria"""
if categoria_id:
categoria = Categoria.objects.get(pk=categoria_id)
form = FormCategoria(instance=categoria)
else:
form = FormCategoria()
return render(request, self.template, {'form': form})
@method_decorator(permissao_geral_required())
def post(self, request, categoria_id=None):
"""Envia para o servidor a nova categoria cadastrada ou atualizada"""
if categoria_id:
categoria = Categoria.objects.get(pk=categoria_id)
form = FormCategoria(instance=categoria, data=request.POST)
mensagem = 'Categoria editada com sucesso!'
else:
form = FormCategoria(request.POST)
mensagem = 'Categoria criada com sucesso!'
if form.is_valid():
form.save()
messages.success(request, mensagem)
return redirect('/categoria/consulta/')
return render(request, self.template, {'form': form})
class CadastroCancelamentoView(View):
"""View para fazer CRUD dos tipos de cancelamento"""
template = 'tipo_cancelamento/salvar.html'
@method_decorator(permissao_geral_required())
def get(self, request, cancelamento_id=None):
"""Envia o formulário para o template"""
if cancelamento_id:
cancelamento = TipoCancelamento.objects.get(pk=cancelamento_id)
form = FormTipoCancelamento(instance=cancelamento)
else:
form = FormTipoCancelamento()
return render(request, self.template, {'form': form})
@method_decorator(permissao_geral_required())
def post(self, request, cancelamento_id=None):
"""Envia os valores do tipo de cancelamento para o
banco de dados"""
if cancelamento_id:
cancelamento = TipoCancelamento.objects.get(pk=cancelamento_id)
form = FormTipoCancelamento(instance=cancelamento,
data=request.POST)
else:
form = FormTipoCancelamento(request.POST)
if form.is_valid():
form.save()
return redirect('/')
return render(request, self.template, {'form': form})
class CadastroDispositivoView(View):
"""Cadastra os dispositivos"""
template = 'dispositivo/salvar.html'
@method_decorator(permissao_geral_required())
def get(self, request, dispositivo_id=None):
"""Cria um formulário para cadastrar o dispositivo"""
if dispositivo_id:
dispositivo = Dispositivo.objects.get(pk=dispositivo_id)
form = FormDispositivo(instance=dispositivo)
else:
form = FormDispositivo()
return render(request, self.template, {'form': form})
@method_decorator(permissao_geral_required())
def post(self, request, dispositivo_id=None):
"""Envia para o servidor os dispositivos cadastrados"""
if dispositivo_id:
dispositivo = Dispositivo.objects.get(pk=dispositivo_id)
form = FormDispositivo(instance=dispositivo, data=request.POST)
mensagem = 'Dispositivo editado com sucesso!'
else:
form = FormDispositivo(request.POST)
mensagem = 'Dispositivo inserido com sucesso!'
if form.is_valid():
form.save()
messages.success(request, mensagem)
return redirect('/dispositivo/consulta/')
return render(request, self.template, {'form': form})
class ImportaCidade(View):
"""Importa as cidades"""
template_name = 'cidade/importa.html'
@method_decorator(permissao_geral_required())
def get(self, request):
"""Envia um formulário para o template"""
form = FormArquivo()
return render(request, self.template_name, {'form': form})
@method_decorator(permissao_geral_required())
def post(self, request):
"""Envia o arquivo importado para o servidor"""
arq = request.FILES['arquivo']
i = 0
estado = UF.objects.filter(sigla='SC').first()
if estado is None:
estado = UF(sigla='SC', nome='Santa Catarina')
estado.save()
for linha in arq:
try:
linha = linha.encode('UTF-8')
cod = int(linha[:4])
cidade = linha[4:44].strip()
nova_cidade = Cidade(uf_id=estado.id, codigo=cod, nome=cidade)
nova_cidade.save()
i += 1
except Exception:
continue
return render(request, self.template_name, {'qtd': i, 'envio': True})
class CadastroCorView(View):
"""Cadastra as cores"""
template = 'cor/salvar.html'
@method_decorator(permissao_geral_required())
def get(self, request, cor_id=None):
"""Pega o formulário e envia para o template"""
if cor_id:
cor = Cor.objects.get(pk=cor_id)
form = FormCor(instance=cor)
else:
form = FormCor()
return render(request, self.template, {'form': form})
@method_decorator(permissao_geral_required())
def post(self, request, cor_id=None):
"""Envia as novas cores para a base no servidor"""
if cor_id:
cor = Cor.objects.get(pk=cor_id)
form = FormCor(instance=cor, data=request.POST)
mensagem = 'Cor editada com sucesso!'
else:
form = FormCor(request.POST)
mensagem = 'Cor inserida com sucesso!'
if form.is_valid():
form.save(request)
messages.success(request, mensagem)
return redirect('/cor/consulta/')
return render(request, self.template, {'form': form})
class CadastroDispositivoAcessoView(View):
"""Cadastra os dispositivos"""
template_name = 'dispositivo/acesso.html'
@method_decorator(permissao_geral_required())
def get(self, request, dispositivo_id=None):
"""Cadastra o acesso"""
if dispositivo_id:
acesso = Acesso.objects.get(pk=dispositivo_id)
dispositivo = Dispositivo.objects.get_or_create(
imei=acesso.imei)[0]
dispositivo.ativo = True
dispositivo.save()
Acesso.objects.get(pk=dispositivo_id).delete()
return redirect('/dispositivo/acesso/')
class GeraDet(View):
template_name = 'det/gera.html'
@method_decorator(permissao_geral_required())
def get(self, request, filtro='0', formato=''):
det = datetime.now().strftime("%Y%m%d%H%M%S")
config = Configuracao_DET.objects.filter().order_by('-id')[0]
nome_det = str(request).split('/')[3]
if nome_det != "format":
id_det = DET.objects.get(codigo=nome_det)
sequencial_arquivo = str(id_det.id)
else:
sequencial_arquivo = str(len(DET.objects.all()) + 1)
print("det", DET.objects.all())
while len(sequencial_arquivo) < 6:
sequencial_arquivo = '0' + sequencial_arquivo
autuador = ('0' * (6 - len(config.autuador))) + config.autuador
nome_arq = config.formato + '.' + config.cod_entidade + '.' + \
autuador + '.' + sequencial_arquivo + '.DET'
arq = open(nome_arq, 'w')
if formato == '1':
zp = zipfile.ZipFile(nome_arq[:len(nome_arq) - 4] + '.zip', 'w')
if filtro == '0':
det_novo = DET(codigo=det)
det_novo.save()
# topo
if config:
hoje = datetime.now()
filler_entidade = len(config.entidade)
entidade = config.entidade
if filler_entidade < 40:
qtd = 40 - filler_entidade
# entidade = config.entidade.ljust(qt)
entidade = config.entidade + (' ' * qtd)
data = hoje.strftime('%Y%m%d')
hora = hoje.strftime('%H%M')
filler = (182 * ' ')
registro_inicial = (5 * '0') + '1'
cod_entidade = (str(config.cod_entidade))
while len(cod_entidade) < 3:
cod_entidade = '0' + cod_entidade
topo = '0' + config.formato + cod_entidade + entidade + data + hora + str(
sequencial_arquivo) + autuador + config.tipo_arquivo + \
filler + str(registro_inicial)
arq.write(topo + '\r\n')
# infracoes
infracoes = Infracao.objects.filter(
det=filtro, veiculo_id__isnull=False).distinct()
# infracoes = Infracao.objects.filter(veiculo_id__isnull=False).distinct() # TESTE
sequencial_registro = int(registro_inicial)
for i in infracoes:
# Registro de infracoes
sequencial_registro = int(sequencial_registro) + 1
if len(str(sequencial_registro)) < 6:
sequencial_registro = ('0' * (6 - len(str(sequencial_registro)))) \
+ str(sequencial_registro)
tipo_registro = config.tipo_registro
n_auto = str(i.id)
if len(n_auto) < 10:
n_auto = ('0' * (10 - len(n_auto))) + n_auto
local = i.local
if len(local) < 80:
local = local.rstrip()
local = local + (' ' * (80 - len(local)))
cod_municipio = config.cod_municipio
tipo_inf = str(i.tipo_infracao_id)
if tipo_inf == '':
cod_tipo_inf = '0' * 4
desmembramento = '0'
if len(tipo_inf.split('-')) > 1:
cod_tipo_inf = ''
for y in range(len(tipo_inf.split('-'))):
cod_tipo_inf += tipo_inf.split('-')[y]
cod_tipo_inf = cod_tipo_inf[:4]
desmembramento = cod_tipo_inf[-1]
condutor = '0'
cnh = '0' * 11
complemento = ' ' * 80
if i.is_condutor_identi:
condutor = '1'
cnh = i.infrator.cnh.split('/')
cnh = cnh[0]
if len(cnh) == 0:
condutor = '3'
if len(cnh) < 11:
cnh = '0' * (11 - len(cnh)) + cnh
filler = ' ' * 31
infracao = tipo_registro + n_auto + i.veiculo.placa + i.veiculo.cidade.uf.sigla +\
i.data_infracao.strftime(
'%Y%m%d') + i.data_infracao.strftime(
'%H%M%S') + local + cod_municipio + cod_tipo_inf + desmembramento + \
condutor + cnh + i.agente.cpf + complemento + filler + str(
sequencial_registro)
arq.write(infracao.encode('UTF-8') + '\r\n')
if i.det == '0':
i.det = det
i.save()
if len(str(qtd)) < 6:
qtd = ('0' * (6 - qtd)) + str(qtd)
# trailler
sequencial_infracao = int(sequencial_registro) - 1
if len(str(sequencial_infracao)) < 6:
sequencial_infracao = ('0' *
(6 - len(str(sequencial_infracao)))
) + str(sequencial_infracao)
sequencial_registro = int(sequencial_registro) + 1
if len(str(sequencial_registro)) < 6:
sequencial_registro = ('0' *
(6 - len(str(sequencial_registro)))
) + str(sequencial_registro)
trailler = '9' + str(sequencial_infracao) + (
' ' * 250) + str(sequencial_registro)
arq.write(trailler + '\r\n')
arq.close()
# zipfile
if formato == '1':
zp.write(nome_arq)
zp.close()
os.remove(nome_arq)
nome_arq = nome_arq[:len(nome_arq) - 4] + '.zip'
down = open(nome_arq, 'r')
response = HttpResponse(down,
content_type='application/force-download')
response[
'Content-Disposition'] = 'attachment; filename=%s' % nome_arq
os.remove(nome_arq)
return response
else:
return redirect('/config/get/det')
class UploadDetransLogoView(View):
"""View que faz um upload da logo para o servidor"""
template = 'upload/logo.html'
@method_decorator(permissao_geral_required())
def get(self, request, sistema_id=None):
"""Envia o template para fazer a mudança do logo"""
if len(Sistema.objects.filter()) > 0:
sistema = Sistema.objects.last()
sistema_id = sistema.id
if sistema_id:
print 'aqui'
sistema = Sistema.objects.get(pk=sistema_id)
form = LogoForm(instance=sistema)
else:
print 'else'
form = LogoForm()
return render(request, self.template, {'form': form})
@method_decorator(permissao_geral_required())
def post(self, request):
"""Envia a imagem para ser usada como logo"""
sistema = Sistema.objects.filter()
arquivos = ['jpg', 'jpeg', 'JPG', 'JPEG', 'png', 'PNG']
if len(sistema) > 0:
if not request.FILES:
sistema_id = Sistema.objects.latest('id').id
sistema = Sistema.objects.get(pk=sistema_id)
form = LogoForm(request.POST or None,
request.FILES or None,
instance=sistema)
form.logo = sistema.logo
else:
sistema_id = Sistema.objects.latest('id').id
sistema = Sistema.objects.get(pk=sistema_id)
form = LogoForm(request.POST or None,
request.FILES or None,
instance=sistema)
else:
form = LogoForm(request.POST or None, request.FILES or None)
if sistema.logo or 'logo' in request.FILES and str(
request.FILES['logo']).split('.')[-1] in arquivos:
print 'if'
if form not in globals():
form = LogoForm(request.POST or None,
request.FILES or None,
instance=sistema)
if form.is_valid():
form.save(request)
return redirect('/')
else:
return render(request, self.template, {'form': form})
else:
if form not in globals():
form = LogoForm(instance=Sistema.objects.latest('id'))
return render(request, self.template, {
'form': form,
'erro': 'erro'
})
